C++ — 147 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. 147 operations available: 73 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

73Refactor

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-to-statement`	Add braces around single-line if/for/while body
`add-break-to-switch-case`	Add break statement to a switch case that falls through
`add-const-method`	Add const qualifier to a C++ member function
`add-const-qualifier`	Add const to variables, parameters, or member functions
`add-constexpr`	Add constexpr specifier to a C++ function or variable
`add-default-parameter`	Add default value to function parameter
`add-explicit-keyword`	Add explicit keyword to single-parameter constructor
`add-include-guard`	Generate #ifndef/#define/#endif include guard
`add-member-initializer`	Add member to a constructor initializer list
`add-missing-include`	Add missing #include directive
`add-noexcept`	Add noexcept specifier to a C++ function
`add-nullptr-check`	Wrap pointer dereference in nullptr check
`add-override`	Add override specifier to a C++ virtual function
`add-virtual-keyword`	Add virtual keyword to function
`change-signature`	Modify function parameters, return, generics
`convert-c-cast-to-cpp-cast`	Replace C-style cast (Type)expr with static_cast<Type>(expr)
`convert-enum-to-enum-class`	Convert unscoped enum to scoped enum class
`convert-for-loop-to-range-based`	Convert index-based for loop to C++11 range-based for loop
`convert-for-to-while`	Convert for loop to while loop
`convert-function-to-lambda`	Convert simple function to lambda expression
`convert-global-to-static`	Convert global variable/function to static (file-local)
`convert-if-to-switch`	Convert if-else chain to switch statement
`convert-if-to-ternary`	Convert simple if-else to ternary operator
`convert-lambda-to-function`	Convert lambda expression to named function
`convert-local-variable-to-const`	Convert local variable to const
`convert-macro-to-constexpr`	Replace #define constant macro with constexpr auto
`convert-macro-to-inline-function`	Replace #define macro with inline function
`convert-postfix-to-prefix-operator`	Convert postfix operator (i++) to prefix (++i)
`convert-raw-array-to-vector`	Convert a C-style raw array to std::vector
`convert-string-literals-to-std-string`	Convert C-style string literal to std::string
`convert-switch-to-if-chain`	Convert switch statement to if-else chain
`convert-ternary-to-if`	Convert ternary operator to if-else statement
`convert-to-smart-pointer`	Convert a raw pointer new expression to a smart pointer
`convert-while-to-for`	Convert while loop to for loop
`extract-constant`	Extract value to named constant
`extract-header`	Extract a class declaration into a .hpp header file
`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-base-class-methods`	Generate override stubs for all virtual methods from a base class
`generate-class-with-raii`	Generate an RAII class skeleton with constructor/destructor pair
`generate-comparison-operators`	Generate comparison operators (==, !=, <, >, <=, >=)
`generate-const-reference-getter`	Generate a const reference getter for a member variable
`generate-copy-assignment`	Generate copy assignment operator
`generate-copy-constructor`	Generate copy constructor
`generate-default-constructor`	Generate explicit default constructor
`generate-destructor`	Generate explicit destructor
`generate-getter`	Generate const getter for member variable
`generate-getter-setter`	Generate getter and setter for member variable
`generate-interface-methods`	Generate pure virtual method implementations for an abstract base class
`generate-member-initializer-list`	Generate member initializer list for constructor
`generate-move-assignment`	Generate move assignment operator
`generate-move-constructor`	Generate move constructor
`generate-null-check`	Generate nullptr check with error handling
`generate-operator-overloads`	Generate operator overloads for a C++ class
`generate-rule-of-five`	Generate rule-of-five special member functions for a C++ class
`generate-scoped-enum`	Generate an enum class declaration with given name and values
`generate-setter`	Generate setter for member variable
`generate-unit-test-skeleton`	Generate Google Test or CppUnit test case stub
`import-add`	Add an #include directive
`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-function-call`	Inline function body at call site
`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)]
`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)]
`outline-function-body`	Extract function body from inline implementation
`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-unused-include`	Remove unused #include directives
`remove-unused-macro`	Remove a #define macro that has no references in the file
`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)]
`reorder-function-parameters`	Reorder function parameters with call-site updates
`simplify-boolean-expression`	Simplify boolean expressions by removing redundant operations
`simplify-if-statement`	Simplify if statements by reducing nesting or merging conditions
`simplify-null-check`	Simplify null checks with modern C++ patterns
`wrap-raii`	Wrap a resource acquisition with a RAII guard struct

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

← Common LispCrystal →