Capabilities
More than 400 tools, one idea behind all of them: the answer comes from the compiler's view of the solution, not from text. These are the families, and the questions each one answers.
Navigation and understanding
Symbols, references, callers, implementations, inheritance, type
outlines, declaration source and project docs. The lookup that greps
try to approximate — resolved through Roslyn, so overloads, generics,
partial types and interface dispatch are answered exactly.
find_symbol, read_symbol,
find_references, find_callers,
find_implementations, get_type_members,
get_symbol_info, get_xml_docs.
Analysis
Whole-solution audit, compiler diagnostics and the mechanical
ones fixed, inspections with code fixes, cyclomatic and
cognitive complexity with the lines that own the score, static Big-O
estimates, churn × complexity hotspots, dead code, structural
duplicates, CWE-tagged security findings, async anti-patterns,
allocation anti-patterns, dependency injection and namespace coupling.
solution_audit, inspect_code,
complexity_report, analyze_complexity,
find_security_issues, find_dead_code,
fix_complexity.
Refactoring
A full semantic refactoring catalogue — rename, extract method, extract
class and superclass, change signature, move type and members, convert
between kinds — most of it compiler-gated: an edit that would introduce
an error is refused, and every write is recorded so it can be reverted.
apply_rename, extract_method,
change_signature, safe_delete,
move_type, reduce_complexity.
Code style
simplify_code applies the IDE's mechanical quick fixes
without an IDE: the rewrite engine behind the quick-fix popup, with a
per-document compiler gate, option-driven rules that respect your
.editorconfig, and a recorded, revertible edit history.
Visual Basic has its own layer, simplify_vb_code.
apply_code_fix executes the analyzers' own fixers;
code_cleanup, format_code and
optimize_usings complete the sweep.
Razor, Blazor and XAML
Razor pages and Blazor components are read from disk with a dedicated
scanner: inventory and wiring, markup/accessibility/maintainability
rules, and CWE-tagged security rules — with verified, history-recorded
edits. XAML has its own layer: inventory with the project's dialect,
markup diagnostics, binding paths checked against their data
type, the element tree and navigation by name, key and style.
razor_pages, analyze_razor_pages,
find_razor_vulnerabilities, razor_edit,
xaml_pages, xaml_bindings.
Runtime work
Build with structured diagnostics, run, test with coverage, debug
through a real DAP debugger with breakpoints and watch windows, run
benchmarks, and profile a live .NET process — CPU, GC, allocations,
I/O, locks, dumps — with verdicts in plain language.
build_project, run_tests,
get_test_coverage_map, debug_launch,
quick_benchmark, profile_slowdown.
The wider loop
The plumbing around the code: NuGet package facts, vulnerability checks
and fixes, .NET modernization with a build gate that rolls back, EF
Core migrations, Git and GitHub, Docker, repository scaffolding
(licenses, CONTRIBUTING, CI workflows), a solution-scoped kanban board
with memory, and run_plan to execute a whole dependency
graph of tool calls in one round trip.
update_solution, check_nuget_vulnerabilities,
ef_migrations, git_conflicts,
gh_pr, board_brief, run_plan.
Metacode
One canonical pseudocode model for C#, Visual Basic, Razor, JavaScript,
Python, C++ and Rust — and for code recovered from binaries: .NET
assemblies decompiled with ILSpy, native binaries recovered with
Ghidra. The same algorithm prints the same body whichever frontend
produced it, so two spellings of an algorithm can be compared line by
line, and a decompiled library can be queried like source.
metacode_translate, metacode_compare,
decompile_to_metacode, analyze_native_binary.
The complete catalogue — every tool, grouped by area, with a one-line description — is the tool catalogue in the repository ; the guides in this area show the ways of working with each family.