Roslyn CodeLens

Analyze the blast radius of changing a symbol — shows every file, project, and call site affected. Combines find_references and find_callers into a single impact summary. Use before renaming, changing signatures, or removing a type/method.

Analyze control flow within a range of statements in a C# method. Returns reachability of start/end points, return statements, and exit points. Useful for detecting unreachable code and understanding branching.

Analyze data flow within a range of statements in a C# method. Returns variables declared, read, written, captured by lambdas, and flowing in/out of the region. Useful for understanding variable lifecycle before extracting code.

Get a comprehensive analysis of a method in one call: signature, location, all callers, and all outgoing calls (methods this method invokes). More efficient than calling find_callers separately.

Apply a code action (refactoring or fix) by its title. Use get_code_actions first to discover available actions. Defaults to preview mode (returns diff without writing files). Set preview=false to apply changes to disk.

Add, remove, or reorder a method's parameters and update every call site (Roslyn's own change-signature engine). Cascades to overrides and interface implementations, rewrites named and optional arguments, and preserves an extension method's `this` parameter; the overrides and implementations it also rewrote are listed in `CascadedTo`. Operations apply in order: `remove` drops `parameter`; `reorder` takes `order`, a full permutation of the parameters surviving at that point; `add` appends `name` plus `type` and REQUIRES `callSiteValue` — the expression every existing call site will pass, since the tool never guesses call-site semantics — with an optional `defaultValue` that instead makes the parameter optional and leaves existing calls untouched. Rejected as unsafe: an added name that is not a valid C# identifier or collides with an existing parameter; a `type` that does not resolve, or resolves ambiguously (qualify it); moving or removing an extension method's `this` parameter (it must stay first); and any signature that would leave a surviving `params` array anywhere but last — add the parameter and reorder it before the `params` array, or remove that array. Defaults to preview mode (returns edits without writing files); set `preview=false` to apply. New compiler errors the change would introduce are reported as Conflicts, and apply mode refuses to write them unless `force=true`. Source-defined methods only; overloaded names must be disambiguated.

Check user-supplied layering rules against the solution's real semantic type graph (resolved symbols, not `using` directives — so a fully qualified reference with no `using` is still caught, and an unused `using` is not reported). Rule kinds: `forbid` (a dependency from `from` to `to` is a violation) and `allowOnly` (a dependency from `from` to anything outside `to` is a violation). TWO SEMANTICS YOU MUST KNOW TO READ AN EMPTY RESULT CORRECTLY. (1) `allowOnly` evaluates ONLY solution-internal, non-generated targets: references to framework and NuGet namespaces such as `System.Collections.Generic` are ignored (otherwise every file would violate every `allowOnly` rule), and so are types declared entirely in generated code, which the caller cannot remove. To restrict a framework or generated namespace, write an explicit `forbid` — that path DOES evaluate metadata and generated targets. (2) Self-references are always allowed: a scope depending on itself is never a violation, under either kind. Results are grouped per violated `rule` plus `sourceScope` plus `targetScope` edge, each with a full `referenceCount` and the first `maxSitesPerViolation` sites. Sorted by rule order, then by descending reference count. Generated code is never reported as the SOURCE of a violation under either kind. Envelope adds a `byRule` / `totalReferences` / `rulesEvaluated` summary.

Detect six classes of async/await misuse across all production projects: sync-over-async (.Result, .Wait*, GetAwaiter().GetResult()), async void outside event handlers, missing await in async methods, and fire-and-forget tasks. Returns a summary plus a per-violation list (severity error/warning, location, containing method, snippet). Skips test projects and generated code. Static analysis only — no fix suggestions.

Find all types and members decorated with a specific attribute (e.g., Obsolete, Authorize, Serializable). Returns an envelope with items, totalCount, truncated, limit, and a byProject summary.

Diff the current solution's public API surface against a baseline (JSON snapshot from a prior get_public_api_surface run, or a baseline .dll file). Reports five change kinds: Removed/KindChanged/AccessibilityNarrowed (Breaking) plus Added/AccessibilityWidened (NonBreaking). Returns a summary plus a per-change list (kind, severity, fully-qualified name, entity kind, project, file, line, details). Sort: Breaking before NonBreaking, then name ASC. Limitations: return type changes, sealed-ness changes, and nullable annotation changes are not detected (PublicApiEntry schema doesn't capture them).

Find every call site for a method. Returns an envelope with items, totalCount, truncated, limit, and a byProject summary.

Find the `catch` clauses that handle an exception type across the solution, and say what each one does with it. Each item reports `hasFilter` (a `when` clause, so the handler may decline at runtime), `rethrows` (the body contains a bare `throw;`) and `isEmpty` (an empty handler body) — together these answer 'who is silently swallowing this exception?' in a single call. By default only clauses declaring exactly the requested type match; set `includeBaseClauses` to also surface handlers that catch a base type, including `catch (Exception)` and bare `catch`, since those bind the requested type too. `caughtType` is null for a bare `catch`. The exception type may live in source or in metadata. Returns an envelope with items, totalCount, truncated, limit and a `byType` / `byProject` summary, sorted by file, line, column.

Detect circular dependencies in the project reference graph or namespace dependency graph. Returns an envelope with items sorted by cycle length desc, totalCount, truncated, and limit (default 100).

Detect IDisposable / IAsyncDisposable instances at risk of leaking. Two patterns: local variables holding a disposable that aren't wrapped in using/await using/returned/assigned-to-field-or-out-parameter (warning), and bare-expression-statement discards of a disposable creator/factory (error). Returns a summary plus a per-violation list (severity error/warning, location, containing method, snippet). Skips test projects and generated code. Scope: methods only (not constructors/accessors/operators); ownership transfer via method/constructor argument is not detected. Static analysis only — no fix suggestions.

Find every += and -= site for an event symbol across the solution. Accepts source events (e.g. 'MyClass.Clicked') or metadata events (e.g. 'System.Diagnostics.Process.Exited'). Each result reports the source location, the resolved handler (method FQN, or a synthetic name like 'lambda at File.cs:N' for inline handlers), and the subscription kind (Subscribe for +=, Unsubscribe for -=). Use this for memory-leak audits (compare subscribe/unsubscribe pairs), UI event subscriber inspection, or when Grep over '+= EventName' would miss qualified or fully-typed subscription sites. Returns an envelope with items sorted by file path then line, totalCount, truncated, and limit (default 500).

Find types that combine high size with high coupling — 'god classes' that violate single-responsibility and become refactoring nightmares. Sharper signal than find_large_classes alone: a 1000-line internal helper used only by its own namespace is not flagged, but a 200-line class called from 15 different namespaces is. Two axes: size (lines/members/fields) and coupling (incoming/outgoing namespace counts). A type qualifies when it crosses ALL THREE size thresholds AND at least one coupling threshold — keeps DTOs (high field count only) and dispatchers (high member count only) off the list. Defaults: lines >= 300, members >= 15, fields >= 10, incoming-namespaces >= 5, outgoing-namespaces >= 5. Each threshold is independently configurable. BCL namespaces (System.*, Microsoft.*) excluded from outgoing count. Test projects, generated code, interfaces, and nested types are skipped. Sort: total axes exceeded DESC, then line count DESC.

Find all classes/structs implementing an interface or extending a class. Returns an envelope with items, totalCount, truncated, and limit.

Find classes and structs that exceed member count or line count thresholds. Returns an envelope with items sorted worst-first (highest size first), totalCount, truncated, and limit (default 100).

Check .NET naming convention compliance: PascalCase types/methods/properties, camelCase parameters, I-prefix interfaces, _ prefix private fields. Returns an envelope with items, totalCount, truncated, limit (default 500), and a byRule summary.

Find every call site referencing [Obsolete]-marked symbols in the solution, grouped by deprecation message and severity. Sharper than find_attribute_usages for migration-planning workflows: tells you 'we have 5 distinct deprecations pending; this one has 80 sites and is an error; that one has 3 sites and is a warning.' Includes both source-marked and metadata-marked obsoletes (third-party NuGet deprecations are surfaced too). Symbols with zero usages are omitted (no migration needed). Sort: errors first, then by usage count descending, then by symbol name. Test projects skipped. Project filter is case-insensitive.

Find all references to a symbol (type, method, property, field, or event) across the solution, each tagged with a kind. Kinds: `read`, `write`, `readwrite` (compound assignment / `++` / `ref`), `invocation`, `method_group`, `object_creation`, `cast`, `type_check` (`is` / patterns / `as`-tests), `typeof`, `base_type`, `type_constraint`, `type_argument`, `declaration`, `attribute`, `nameof`, `xml_doc`, and `usage` (rare fallback). Pass `kinds` to return only some (e.g. `["write","readwrite"]` for mutation sites). Envelope adds a `byKind` summary. Multiple references on one line are reported separately with a `column`.

Detect dynamic/reflection-based usage like Type.GetType, Activator.CreateInstance, MethodInfo.Invoke. Returns an envelope with items, totalCount, truncated, limit (default 500), and a byKind summary.

List test methods that exercise the given production symbol. Recognises xUnit, NUnit, and MSTest. Set transitive=true to follow helper methods up to maxDepth levels (default 3, max 5).

Find every place an exception type is thrown across the solution — `throw new T(...)`, `throw expr;` and bare `throw;` rethrows (whose type comes from the enclosing `catch`). The exception type may live in source or in metadata, so `System.ArgumentNullException` works as well as your own `MyApp.DomainException`. Set `includeDerived` to also match subclasses of the requested type. Every throw in the file is reported, including throws inside lambdas and local functions, attributed to the member that contains them — use `get_exception_flow` instead when the question is which exceptions escape a specific method. Returns an envelope with items, totalCount, truncated, limit and a `byType` / `byProject` summary, sorted by file, line, column.

Report public methods and properties that no test method transitively reaches (within 3 helper hops). Output sorted by cyclomatic complexity descending, with a coverage summary including a riskHotspotCount (uncovered with complexity >= 5). Recognises xUnit, NUnit, MSTest. Reference-based static analysis — does not parse runtime coverage data.

Find potentially unused types and members (dead code detection). Checks public symbols for references across the solution. Filters out test methods, MCP tools, source-generator output, MEF-composed services, and interop-laid-out fields. Returns an envelope with items, totalCount, truncated, limit (default 500), and a summary including byKind + filteredOut counts.

Emits a test-class skeleton (parseable C#) for a method or type. Pass a type FQN like 'MyApp.Services.OrderService' to get a full test class with one stub per public method, or a method FQN like 'MyApp.Services.OrderService.PlaceOrder' to get a single stub. Returns framework, suggested file path, class name, full file contents (as text), and TodoNotes for things to wire up (e.g. constructor dependencies). The tool does NOT write to disk — agent decides what to do with the text. Pairs naturally with find_uncovered_symbols / get_test_summary. Stubs include happy-path Fact, Theory + InlineData for primitive-param methods, and Assert.Throws assertions per distinct direct-throw exception type. Async (Task-returning) methods detected automatically. Properties, indexers, operators, and constructors are excluded from per-method enumeration. Framework auto-detected from solution test projects (tie → xUnit); override with framework='xunit' / 'nunit' / 'mstest'.

Transitive caller and/or callee graph for a method symbol, depth-bounded with cycle detection. Output is an adjacency-list dict per direction (callees and/or callers), where each visited symbol maps to its outgoing edges. Direction: 'callees' (what this method transitively calls), 'callers' (who reaches this method), or 'both'. External (BCL/NuGet) callees appear as terminal leaves with isExternal=true. Declared signature only on callee side — no virtual dispatch resolution; agent uses find_implementations separately if needed. Callers side resolves dispatch naturally via Roslyn SymbolFinder. Hard cap on total visited nodes (default 500) — sets truncated=true if hit; edges to truncated targets are still recorded against the source node. Use this instead of recursive find_callers / analyze_method calls when you need depth > 1.

List available code actions (refactorings and fixes) at a position in a C# file. Optionally specify endLine/endColumn to select a range for extract-method style refactorings. Returns action titles that can be passed to apply_code_action. Returns an envelope with items sorted by kind then title, totalCount, truncated, and limit (default 100).

Get available code fixes for a specific diagnostic at a file location. Returns structured text edits that can be reviewed and applied. Returns an envelope with items sorted by title, totalCount, truncated, and limit (default 100).

Calculate complexity for members (methods, constructors, properties, indexers, operators). Reports both 'complexity' (cyclomatic - the number of paths, starts at 1) and 'cognitive' (how hard the code is to follow, starts at 0 - a 0 is not a bug), plus 'maxNesting'. The 'metric' parameter selects which of the two the threshold filters on and the sort uses. Returns an envelope with items sorted worst-first, totalCount, truncated, limit (default 100), and a summary with max/avg/overThreshold plus maxCognitive.

Scan IServiceCollection extension methods for DI registrations of a type. Returns an envelope with items sorted by service name, totalCount, truncated, and limit (default 200).

List compiler errors and warnings across the solution, optionally including analyzer diagnostics. Analyzer diagnostics require the solution to be trusted (see 'trust_solution'). Returns an envelope with items, totalCount, truncated, limit, and a severity summary.

Which exceptions can escape a method — the 'is calling this safe?' question. Walks the method's callees depth-first (cycle-safe, depth- and node-bounded) collecting every explicit throw, then propagates each one back up the call chain, testing the enclosing `try`/`catch` at the throw and at every call site on the way out. Each item reports `escapes`, the `path` of methods from the analysed method to the one that raises it, and — when it is stopped — `caughtIn`, `caughtFile`, `caughtLine`. A handler with a `when` filter sets `hasFilter` and the exception is still reported as escaping, because the filter may decline at runtime. `origin` is `thrown` for a real throw site in source, or `documented` for an `exception` XML doc tag on a metadata (BCL/NuGet) callee — set `includeDocumented` to false to drop the latter. Throws inside lambdas and local functions are excluded: they escape when that body runs, not at this method's boundary — use `find_throw_sites` for a plain textual scan of throws. Static analysis only: no reflection, no virtual-dispatch resolution, and no implicit runtime failures such as null dereferences. Hitting `maxDepth` or `maxNodes` sets `truncated`.

Answer 'what extension members can I call on this type?' — every extension method and C# 14 extension property applicable to a receiver type, from solution source AND referenced metadata (so BCL LINQ such as `Where`, `Select`, `Chunk` is included). Applicability is decided by the compiler's own reduction, not by name matching: `this IEnumerable<T>` is reported for `string` (which is `IEnumerable<char>`) while `this IEnumerable<string>` is not. Each entry carries the reduced call-site signature (receiver dropped, generic inference applied, return type first: `IEnumerable<int> Where<int>(Func<int, bool>)`, `int Tripled`), kind (`method` or `property`), declaring type, namespace, origin (`source` or `metadata`), source file/line for source members, XML doc summary, and `isStatic`. Read `isStatic` before writing the call: false means an instance call (`value.Doubled()`) and is the normal case even though every extension method is DECLARED static; true means a C# 14 static extension member, called on the type itself (`int.Zero`). Results are NOT filtered by `using` scope — the tool has no call-site position, so every applicable member is reported and its namespace is given for you to add the import. Pass a type name: simple (`Widget`), fully qualified (`MyApp.Widget`), a C# keyword (`int`, `string`), a constructed generic (`List<int>`), an array (`string[]`), a nullable (`int?`), or a tuple (`(int, string)`). Sort: source before metadata, then declaring type, then name.

Get a summary of a C# file: which types are defined in it and any compiler diagnostics. Useful for quickly understanding a file's contents without reading it. Also accepts .razor/.cshtml markup, resolving it to the C# document its source generator produced.

Inspect generated source code from source generators. Returns an envelope with items sorted by project then file path, totalCount, truncated, and limit (default 200).

Answer 'how do I construct this type?' in one call — accessible constructors, static factory methods declared anywhere in the solution, and DI registrations. Constructors report every parameter's type and name, declared accessibility, whether the constructor is compiler-supplied (`isImplicit` — a struct or a class with no declared constructor still has a usable parameterless one), and whether it is obsolete. Factories are static members returning the type, including ones declared on a DIFFERENT type such as `WidgetFactory.Create()`, with `Task<T>`/`ValueTask<T>` unwrapped and flagged `isAsync`. Instance builder methods are excluded because the builder itself would need constructing. Pass `fromProject` to get `accessible` computed for that project, which honours `InternalsVisibleTo` — this is how you find out whether your test project can reach an internal constructor. Without it, `accessible` is null, meaning NOT COMPUTED — which is not the same as false, so do not read a null as 'you cannot call this'. `requiredMembers` lists members that must be set in an object initializer. `diRegistrations` shows where the type is registered in a container — a registered type is usually meant to be resolved rather than constructed by hand. For interfaces, abstract classes and static classes, `instantiable` is false and `note` explains why; use `find_implementations` to find concrete types.

Return the full declaration source (XML docs, attributes, signature, body — original formatting) of one or more members by name: methods (all overloads returned), constructors (request as `Widget.Widget` or fully qualified `Ns.Widget.Widget`; nested types need full qualification), properties, indexers (request as `Type.this` or `Type.this[]`), fields, events. Batch-friendly: pass many names in one call instead of reading whole files. Per-item statuses: ok, notFound, ambiguous (with candidates), metadata (use `peek_il` or `inspect_external_assembly`), unsupportedKind (whole types — use `get_type_overview`). Items keep request order.

List NuGet package references for projects in the solution

Return every user-defined operator and conversion operator on a type in one call — source AND metadata. Each entry includes the operator kind (such as +, ==, implicit, explicit, plus all comparison and bitwise operators), full signature, parameter names/types/modifiers, return type, accessibility, an IsCheckedVariant flag for .NET 7+ checked operators (op_CheckedAddition etc.), XML doc summary, and source location (empty for metadata). Includes compiler-synthesized record equality operators. Returns declared operators only — operators do not inherit in C#. Pass a type name, simple or fully qualified (e.g. 'Vector2', 'MyApp.Money', 'System.Decimal'). Sort: kind ordinal ASC, then parameter count ASC, then signature ordinal ASC.

Return every overload of a method (or constructor) in one call — source AND metadata. Each overload includes the full signature, parameter names/types/modifiers (ref/out/in/params/optional with defaults), return type, accessibility, modifiers (static/virtual/abstract/override/async/extension), generic type parameters, XML doc summary, and source location (empty for metadata). Pass 'Type.Method' for ordinary methods or 'Type.Type' for constructors. Operator overloads are excluded — use get_operators for those. Sort: parameter count ASC, then signature ordinal ASC.

Return the project reference graph (direct and transitive dependencies)

Aggregate 7 health dimensions per project in one call: complexity hotspots, large classes, naming violations, unused symbols, reflection usage, async violations, and disposable misuse. Returns counts per dimension plus the top-N hotspots inline (default 5) so the caller can prioritise without follow-up calls. Use this when answering 'how is this project doing?' / 'where should I focus?' / 'what's the technical debt picture?'. Underlying defaults: complexity threshold 10, large-class limits 20 members / 500 lines, unused symbols excludes internals. Test projects are skipped. Project filter is case-insensitive. Sort: projects ASC by name; hotspots sorted by severity proxy per dimension (cyclomatic complexity desc, line count desc, severity enum desc for async/disposable).

Enumerate every public and protected type and member declared in production projects of the active solution. Returns a deterministically-sorted (name ASC) flat list of API entries (kind, fully-qualified name, accessibility, project, file, line) plus per-kind/per-project/per-accessibility summary buckets. Skips test projects, generated code, compiler-generated members, internal symbols, and protected members on sealed types (unreachable). Inherited members are not repeated under derived types — only declared members appear.

List source generators and their output per project. Returns an envelope with items sorted by project then generator name, totalCount, truncated, and limit (default 100).

One-shot context dump for a type: namespace, base class, interfaces, injected dependencies, public members

Get the current status of a background task by its taskId.

Per-project inventory of test methods. Each test reports framework (xUnit/NUnit/MSTest), attribute kind ([Fact]/[Theory]/[Test]/[TestCase]/[TestMethod]/[DataTestMethod]), data-driven row count, location, and the production symbols it references. Complements find_tests_for_symbol (which goes test → production); this goes project → tests. Use to answer 'what does this test suite cover?' or to break down test counts by framework/attribute. Production projects, generated code, and BCL/framework calls are filtered out of the per-test referenced-symbols list. Project filter is case-insensitive. Sort: tests by (file, line); projects by name ASC.

Walk up (base classes, interfaces) and down (derived types) from a type