C# — 140 Operations for AI Agents

This page is the canonical reference an AI coding agent uses to refactor, query, and analyze C# code through the act MCP server. 140 operations available: 95 refactor, 15 query, 30 analysis. Each operation is callable from Claude Code, Cursor, Codex, OpenCode, or any MCP-compatible agent host. Click any operation for a stable anchor link suitable for citation.

15Query

95Refactor

30Analysis

Query

Operation	Description
`callers`	Find every call site of a function or method across the codebase. Use to understand who depends on a function before changing its signature. Requires LSP. Params: symbol (string) [, file (string)]
`control_flow`	Get a function's control flow — branches, loops, early returns, and basic blocks in execution order. Use to understand complex logic without reading the full implementation. Params: target (string), file (string)
`definition`	Jump to definition — find where a symbol is defined given a usage location. Uses abstract syntax trees by default, no LSP required. Params: symbol (string), file (string), line (u32), column (u32)
`diagnostics`	Get compiler errors and warnings from the language server. Omit `file` for workspace-wide diagnostics. Pass a file path or directory path to scope results. Requires LSP.
`fix_auto`	Auto-fix all deterministic issues in a file, directory, or workspace — missing imports, unused imports, simple type errors. Runs multiple fix-revalidate cycles. Use after making changes to clean up automatically. Requires LSP. Params: none [, file (string), workspace_mode (bool), category (string), commit (bool), max_rounds (u32)]
`get_type`	Get the compiler-inferred type of any expression at a position. Use to understand types without reading surrounding code. Requires LSP. Params: file (string), line (u32), column (u32)
`graph`	Build a dependency graph from a file — trace what it imports and what imports it, across multiple hops. Use to understand module relationships and change impact before refactoring. Params: file (string) [, depth (u32), direction (string), leaves (bool), order (string)]
`import_organize`	Organize, sort, and deduplicate imports in a file. Removes unused imports. Use after adding new code or moving symbols to clean up import blocks automatically. Params: file (string) [, preview (bool)]
`interface`	Get a symbol's public API — signatures, types, and docstrings without implementation bodies. Like skeleton but for a single symbol. Use to understand how to call something without reading its internals. Params: target (string), file (string) [, include_private (bool)]
`mutations`	Identify side effects — what external state a function reads or writes (globals, file I/O, network, etc.). Use to understand if a function is pure or has hidden dependencies. Params: target (string), file (string)
`references`	Find every usage of a symbol across the entire codebase — all files, not just the current one. Use before renaming, refactoring, or deleting to understand full impact. Requires LSP. Params: symbol (string), file (string)
`repo_outline`	Get a compressed overview of the entire repository in one call — file tree with languages, line counts, and optionally symbol names per file. Orders of magnitude cheaper than listing directories and reading files individually. Params: none [, path (string), depth (u32), include (glob), exclude (glob), symbols (bool), max_files (u32), relative (bool)]
`skeleton`	Get a file's structure — function signatures, class declarations, type definitions — without implementation bodies. Use INSTEAD of reading the full file to understand its API. Typically 5-10x fewer tokens than reading the raw file. Params: file (string)
`symbols`	List all symbols (functions, classes, variables, types, constants) defined in a file with their locations and kinds. Use INSTEAD of reading a file when you need to know what's defined in it. Much cheaper than reading the full file. IMPORTANT: file must be a path to a single source file — never a directory or empty string. Params: file (string)
`symbols_batch`	Retrieve symbols from multiple files in a single call. Use instead of calling symbols() in a loop — one request instead of N. Params: none [, files (string[]), ids (string[]), kinds (string[])] — provide files or ids

Refactor

Operation	Description
`add-braces`	Add braces to code blocks
`add-braces-to-if-else`	Add braces to if/else statements
`add-braces-to-switch-section`	Add braces to switch case sections
`add-missing-cases-to-switch`	Add missing enum cases to switch statement
`add-missing-import`	Add missing using statement
`add-null-guard`	Add null check guard clause
`add_argument_name`	Add named argument label to a method call argument
`add_default_value_to_parameter`	Add a default value to a method parameter
`add_using_directive`	Add a using directive for a namespace
`add_using_static_directive`	Add a using static directive for a type
`change-type`	Change variable type annotation
`change-visibility`	Change access modifier (public/private/protected/internal)
`change_type_according_to_expression`	Update declared type to match the actual expression type
`check_expression_for_null`	Wrap expression with a null check
`check_parameter_for_null`	Add null check for a method parameter
`consolidate-import-statements`	Consolidate multiple import statements
`convert-auto-property-to-full-property`	Convert auto property to full property with backing field
`convert-block-body-to-expression-body`	Convert block body to expression body
`convert-lambda-block-body-to-expression-body`	Convert lambda block body to expression body
`convert-string-format-to-interpolation`	Convert string.Format to string interpolation
`convert-switch-to-expression`	Convert switch statement to switch expression
`convert-to-record`	Convert class to record type
`convert_do_to_while`	Convert do-while loop to while loop
`convert_expression_body_to_block_body`	Convert expression-bodied member to block body
`convert_for_to_foreach`	Convert index-based for loop to foreach
`convert_for_to_while`	Convert for loop to while loop
`convert_foreach_to_for`	Convert foreach loop to index-based for loop
`convert_if_to_switch`	Convert if/else chain to switch statement
`convert_lambda_expression_body_to_block_body`	Convert lambda expression body to block body
`convert_switch_to_if`	Convert switch statement to if/else chain
`convert_ternary_to_if_else`	Convert ternary operator to if/else statement
`expand-coalesce-expression`	Expand coalesce operator to null check
`expand-compound-assignment`	Expand compound assignment to explicit operation
`expand-event-declaration`	Expand event declaration to explicit add/remove
`extract-constant`	Extract value to named constant
`extract-function`	Extract code into a new method
`extract-type-to-new-file`	Extract type to new file
`extract-variable`	Extract expression to variable
`extract_expression_from_condition`	Extract sub-expression from condition to named variable
`extract_function`	Extract a code selection into a new function — automatically infers parameters, return types, and inserts the call site. Use instead of manually cutting/pasting code. Works without LSP; LSP improves type inference. Params: file (string), new_name (string), start_line (u32), start_column (u32), end_line (u32), end_column (u32) [, preview (bool)]
`extract_type_declaration_to_new_file`	Extract type declaration to its own file
`extract_variable`	Extract an expression into a named variable — inserts the declaration and replaces the expression with the variable name. Works without LSP. Params: file (string), new_name (string), start_line (u32), start_column (u32), end_line (u32), end_column (u32) [, preview (bool)]
`generate-accessors`	Generate getters/setters for properties
`generate-base-constructors`	Generate constructors matching base class
`generate-constructor`	Generate constructor from fields
`generate-enum-member`	Generate enum member
`generate-enum-values`	Generate enum values
`generate-event-invoking-method`	Generate method to invoke event
`import-add`	Add a using directive to a C# file
`inline`	Inline a variable, function, or method — replace every usage with its definition body, then remove the original. The inverse of extract. Works without LSP (single-file); LSP enables cross-file inlining. Params: file (string), symbol (string) [, line (u32), preview (bool)]
`inline-temp`	Inline temporary variable
`inline_alias_expression`	Inline a using alias at its usage site
`inline_constant_value`	Replace constant reference with its literal value
`inline_method`	Inline method body at call site
`insert-string-interpolation`	Convert string concatenation to interpolation
`insert_body`	Replace a function's implementation body with new code. AST-validated — rejects if the result has parse errors, so you can't accidentally break syntax. Use instead of manual text editing for function rewrites. Params: file (string), symbol (string), code (string) [, commit (bool)]
`introduce-and-initialize-field`	Introduce field and initialize it
`introduce-and-initialize-property`	Introduce property and initialize it
`introduce-constructor`	Generate constructor from uninitialized fields
`introduce-field`	Convert local variable to class field
`introduce-local-variable`	Extract expression to local variable
`introduce-property`	Convert local variable to property with getter/setter
`introduce-variable`	Extract expression to local variable
`introduce_field_to_lock_on`	Introduce a dedicated lock field for thread safety
`invert-if-else`	Invert if-else statement by swapping branches and negating condition
`join-string-expressions`	Join multiple string expressions
`merge_if_statements`	Merge nested if statements into a single compound condition
`merge_switch_sections`	Merge switch sections with identical bodies
`move_symbol`	Move a function, class, or type to a different file and automatically update all imports across the codebase. Use instead of manually cut/paste + fixing imports. Works without LSP (single-file); LSP enables cross-file import updates. Params: file (string), symbol (string), destination (string) [, preview (bool)]
`promote_local_variable_to_parameter`	Promote a local variable to a method parameter
`qualify-name-with-module`	Qualify name with namespace
`remove-braces`	Remove unnecessary braces from code blocks
`remove-braces-from-if-else`	Remove braces from single-statement if/else
`remove-unnecessary-assignment`	Remove unnecessary variable assignment
`remove-unused-import`	Remove unused using statement
`rename`	Rename a symbol and automatically update ALL references across the codebase. Safer and faster than find-and-replace — AST-aware, won't rename strings or comments. Works without LSP (single-file); LSP enables cross-file renames. Params: file (string), old_name (string), new_name (string) [, line (u32), column (u32), preview (bool)]
`rename`	Rename symbol and all references
`rename-class`	Rename class and all references
`rename-field`	Rename field and all references
`rename-method`	Rename method and all references
`rename-parameter`	Rename parameter and all references
`rename-property`	Rename property and all references
`rename_identifier_according_to_type_name`	Rename identifier to match its type name (camelCase)
`rename_method_according_to_type_name`	Rename method to reflect return type
`rename_parameter_according_to_type_name`	Rename parameter to camelCase form of its type
`rename_property_according_to_type_name`	Rename property to PascalCase form of its type
`simplify-if`	Simplify if statement logic
`split-if`	Split compound if condition into nested ifs
`split-variable-declaration`	Split variable declaration and initialization
`use-coalesce-expression-instead-of-if`	Replace if-null with coalesce operator
`use-stringbuilder-instead-of-concatenation`	Replace string concatenation with StringBuilder
`use_explicit_type`	Replace var with the explicit type
`use_implicit_type`	Replace explicit type with var
`wrap-lock`	Wrap code in a lock statement
`wrap-using`	Wrap code in a using statement

Analysis

Operation	Description
`analyze_chokepoints`	Find files that act as critical bottlenecks — high betweenness centrality in the dependency graph (R4). Params: none [, include (string[]), exclude (string[])]. Use include/exclude to restrict the scan scope (e.g. include=["crates"], exclude=["corpus"]).
`analyze_clusters`	Identify tightly coupled groups of files using community detection. Use to discover natural module boundaries and understand which files change together. Params: none [, granularity (string), min_size (u32), include (string[]), exclude (string[])]. Use include/exclude to restrict the scan scope (e.g. include=["crates"], exclude=["corpus"]).
`analyze_cohesion`	Measure intra-module cohesion for each file — ratio of internal to total symbol edges (H2). Params: none [, include (string[]), exclude (string[])]. Use include/exclude to restrict the scan scope (e.g. include=["crates"], exclude=["corpus"]).
`analyze_coupling`	Measure coupling per file — how many files depend on it (afferent) vs how many it depends on (efferent), plus instability and abstractness scores. Use to find the most critical/fragile files. Params: none [, granularity (string), sort (string), threshold (f64), include (string[]), exclude (string[])]. Use include/exclude to restrict the scan scope (e.g. include=["crates"], exclude=["corpus"]).
`analyze_cycle_risk`	Score each circular dependency cycle by its external risk surface (R6 circular risk zones analysis). Params: none [, include (string[]), exclude (string[])]. Use include/exclude to restrict the scan scope (e.g. include=["crates"], exclude=["corpus"]).
`analyze_cycles`	Find circular dependency chains in the codebase. Use to identify import cycles that cause build issues or indicate architecture problems. Params: none [, granularity (string), max_length (u32), include (string[]), exclude (string[])]. Use include/exclude to restrict the scan scope (e.g. include=["crates"], exclude=["corpus"]).
`analyze_dead_code`	Find dead code — functions, classes, and types that are never referenced from any entry point. Use before cleanup to safely identify what can be deleted. Params: none [, entry (string[]), granularity (string), include_tests (bool), include (string[]), exclude (string[])]. Use include/exclude to restrict the scan scope (e.g. include=["crates"], exclude=["corpus"]).
`analyze_depth`	Compute longest transitive dependency chain per file (S4 dependency depth analysis). Params: none [, include (string[]), exclude (string[])]. Use include/exclude to restrict the scan scope (e.g. include=["crates"], exclude=["corpus"]).
`analyze_entry_points`	Detect entry points: main functions, HTTP routes, CLI commands, event listeners, test files (S5). Params: none [, include (string[]), exclude (string[])].
`analyze_export`	Export the full semantic graph (files, symbols, dependencies) in JSON, DOT (Graphviz), or CSV format. Use for visualization or external analysis. Params: none [, format (string), include (string[]), exclude (string[])]. Use include/exclude to restrict the scan scope (e.g. include=["crates"], exclude=["corpus"]).
`analyze_extraction`	Score clusters for service or package extraction viability (M2 extraction candidates analysis). Params: none [, include (string[]), exclude (string[])]. Use include/exclude to restrict the scan scope (e.g. include=["crates"], exclude=["corpus"]).
`analyze_fan_balance`	Compute fan-in/fan-out imbalance for migration ordering guidance (M6 fan balance analysis). Params: none [, include (string[]), exclude (string[])]. Use include/exclude to restrict the scan scope (e.g. include=["crates"], exclude=["corpus"]).
`analyze_features`	Inventory language-specific AST features used in the codebase — async, generics, decorators, etc. (M3). Params: none [, include (string[]), exclude (string[])]. Use include/exclude to restrict the scan scope (e.g. include=["crates"], exclude=["corpus"]).
`analyze_hotspots`	Rank files by composite complexity score — max cyclomatic complexity, statement count, nesting depth (H1). Params: none [, top_n (u32), include (string[]), exclude (string[])]. Use include/exclude to restrict the scan scope (e.g. include=["crates"], exclude=["corpus"]).
`analyze_impact`	Compute change impact for a target file — finds all files directly and transitively depending on it (R1). Params: target (string) [, max_depth (u32), include (string[]), exclude (string[])]. Use include/exclude to restrict the scan scope (e.g. include=["crates"], exclude=["corpus"]).
`analyze_inconsistencies`	Detect inconsistent abstractions — sibling files in the same directory that diverge from the group's structural pattern (H5). Params: none [, include (string[]), exclude (string[])].
`analyze_inheritance`	Detect tangled inheritance — deep hierarchies (>N levels) and diamond inheritance (H6). Params: none [, include (string[]), exclude (string[])].
`analyze_interface_bloat`	Detect interface bloat — files where the public API is disproportionately large relative to implementation (H3). Params: none [, include (string[]), exclude (string[])].
`analyze_interfaces`	Map cross-module interfaces — symbols that cross directory-module boundaries, ranked by interface width (M4). Params: none [, include (string[]), exclude (string[])]. Use include/exclude to restrict the scan scope (e.g. include=["crates"], exclude=["corpus"]).
`analyze_layers`	Detect architectural layers from directory names and find dependency direction violations (S1+S2). Params: none [, detect_only (bool), include (string[]), exclude (string[])]. Use include/exclude to restrict the scan scope (e.g. include=["crates"], exclude=["corpus"]).
`analyze_orphan_types`	Find type definitions used exclusively outside their defining directory (H4 orphan types analysis). Params: none [, include (string[]), exclude (string[])]. Use include/exclude to restrict the scan scope (e.g. include=["crates"], exclude=["corpus"]).
`analyze_patterns`	Find code smells — god functions, deep nesting, high coupling, and other structural issues. Use to identify refactoring targets or assess code quality. Params: none [, tier (string), pattern (string), file (string), severity (string), include (string[]), exclude (string[])]. Use include/exclude to restrict the scan scope (e.g. include=["crates"], exclude=["corpus"]).
`analyze_platform_deps`	Detect platform-specific API usage by scanning imports (M5 platform dependencies analysis). Params: none [, include (string[]), exclude (string[])]. Use include/exclude to restrict the scan scope (e.g. include=["crates"], exclude=["corpus"]).
`analyze_readiness`	Compute migration readiness scores per file — composite of complexity, coupling, porting blockers (M1). Params: none [, include (string[]), exclude (string[])]. Use include/exclude to restrict the scan scope (e.g. include=["crates"], exclude=["corpus"]).
`analyze_roles`	Classify files by architectural role: entry point, routing, business logic, data access, config, test, utility, types, generated (S3). Params: none [, include (string[]), exclude (string[])].
`analyze_seams`	Find the natural boundaries between file clusters — the narrowest points where groups of files communicate. Use to identify where to split modules or add API boundaries. Params: none [, min_cluster_size (u32), max_seam_width (u32), include (string[]), exclude (string[])]. Use include/exclude to restrict the scan scope (e.g. include=["crates"], exclude=["corpus"]).
`analyze_stability`	Compute stability index (R2) and detect stable dependency violations (R3) — flags edges where stable modules depend on unstable ones. Params: none [, index_only (bool), include (string[]), exclude (string[])].
`analyze_surface`	Measure API surface area — count exposed functions, types, and complexity at a module boundary. Use to assess whether an API is too large or leaky. Params: none [, boundary (string), files (string), include (string[]), exclude (string[])]. Use include/exclude to restrict the scan scope (e.g. include=["crates"], exclude=["corpus"]).
`analyze_test_gaps`	Detect source files with no or partial test coverage based on graph import analysis (R5). Params: none [, include (string[]), exclude (string[])]. Use include/exclude to restrict the scan scope (e.g. include=["crates"], exclude=["corpus"]).
`analyze_type_completeness`	Analyze type boundary completeness — detect 'any' types, untyped parameters, missing return types at exported function boundaries (M7). Params: none [, include (string[]), exclude (string[])].

← CrystalCSS →