D — 130 Operations for AI Agents

This page is the canonical reference an AI coding agent uses to refactor, query, and analyze D code through the act MCP server. 130 operations available: 56 refactor, 18 query, 42 analysis, 14 verification. 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.

18Query

56Refactor

42Analysis

14Verify

Query

18 query tools, the same on every supported language. Descriptions live in the shared reference: /docs/query-tools.

callers control_flow data_flow definition diagnostics effect_closure effect_summary fix_auto get_type graph import_organize interface mutations references repo_outline skeleton symbols symbols_batch

Refactor

Operation	Description
`add-braces-d`	Add braces to single-line if/while/for/foreach bodies
`add-const-modifier-d`	Add const modifier to a variable that is never modified
`add-documentation-comment-d`	Add DDoc comment template to declaration
`add-immutable-modifier-d`	Add immutable modifier to a variable that is never modified
`add-import-d`	Add an import statement for a module
`add-missing-break-d`	Add break; to switch case that lacks a terminator
`add-missing-switch-cases-d`	Add default: case to switch statement without one
`add-null-check-d`	Add a null check guard before using a reference
`add-override-modifier-d`	Add override modifier to method declaration
`add-parameter-d`	Add a new parameter to a function definition
`add-safe-attribute-d`	Add @safe attribute to a memory-safe function
`add-scope-guard-d`	Add scope(exit) { ... } cleanup block
`convert-for-to-foreach-d`	Convert indexed for loop to foreach
`convert-foreach-to-for-d`	Convert foreach loop to indexed for loop
`convert-if-to-switch-d`	Convert if/else chain to switch statement
`convert-if-to-ternary-d`	Convert if/else statement to ternary operator
`convert-method-to-property-d`	Convert getter/setter methods to @property syntax
`convert-property-to-method-d`	Convert @property function to explicit getter/setter methods
`convert-switch-to-if-d`	Convert switch statement to if/else chain
`convert-ternary-to-if-d`	Convert ternary operator to if/else statement
`extract-method-d`	Extract code block into a new function
`extract-type-declaration-d`	Move a type declaration to a separate file
`extract-variable-d`	Extract an expression into a new local 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), receipt (bool)]
`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-constructor-d`	Generate a constructor for a class or struct
`generate-documentation-template-d`	Generate DDoc /** Params: ... Returns: ... */ template
`generate-equals-method-d`	Generate opEquals and opCmp for equality comparison
`generate-field-d`	Generate a field declaration in a class/struct
`generate-getter-d`	Generate a getter method for a private field
`generate-interface-implementation-d`	Generate stub methods implementing an interface
`generate-method-stub-d`	Generate empty method with given signature in a class/struct
`generate-operator-overload-d`	Generate opAdd/opMul/etc operator overload method
`generate-parameter-validation-d`	Generate null/range checks for function parameters
`generate-setter-d`	Generate a setter method for a private field
`generate-to-string-method-d`	Generate a toString method for string representation
`generate-unittest-block-d`	Generate a unittest block for testing a function
`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), receipt (bool)]
`inline-method-d`	Inline a method body at its call sites
`inline-variable-d`	Inline a variable declaration into its usage sites
`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-constant-d`	Extract magic number/string into named enum constant
`introduce-parameter-d`	Convert a local variable into a function parameter
`introduce-variable-d`	Extract expression into new local variable using auto type
`move-field-d`	Move a field to a different struct/class
`move-method-d`	Move a method to a different struct/class
`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), receipt (bool)]
`organize-imports-d`	Sort and deduplicate import statements
`recipe_run`	Run a codemod recipe: declarative match → transform → optional verify across modeled grammars. Preview lists matches; apply writes with optional E7 receipts and all-or-nothing rollback. Returns a per-site report.
`remove-parameter-d`	Remove an unused parameter from a function definition
`remove-unreachable-code-d`	Remove code after return/break/continue/throw
`remove-unused-import-d`	Remove an unused import 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), receipt (bool)]
`rename-identifier-d`	Rename an identifier across all references in the file
`rename-parameter-d`	Rename a function parameter across its definition and body
`use-string-interpolation-d`	Replace format() calls with D string interpolation

Analysis

42 analysis tools, the same on every supported language. Descriptions live in the shared reference: /docs/analysis-tools.

analyze_api_diff analyze_chokepoints analyze_clones analyze_clusters analyze_cohesion analyze_conformance analyze_coupling analyze_cycle_risk analyze_cycles analyze_dead_code analyze_depth analyze_entry_points analyze_export analyze_extraction analyze_fan_balance analyze_features analyze_hotspots analyze_impact analyze_inconsistencies analyze_inheritance analyze_interface_bloat analyze_interfaces analyze_layers analyze_orphan_types analyze_patterns analyze_platform_deps analyze_readiness analyze_roles analyze_seams analyze_stability analyze_surface analyze_test_gaps analyze_thickness analyze_type_completeness churn_hotspots co_change_clusters coverage_overlay ownership_map profile_overlay simulate split_module trace_overlay

Verify

14 verify tools, the same on every supported language. Descriptions live in the shared reference: /docs/verification.

bisect_regression gate generate_test_harness scan secret_surface summarize_pr taint_flow unsafe_surface verify_behavioral_equivalence verify_contract_preserved verify_diff_semantics verify_port_parity verify_side_effects verify_test_impact

← CUEDart →