@optave/codegraph 2.6.0 → 3.0.1

package/src/mcp.js

@@ -6,10 +6,11 @@
  */
 
 import { createRequire } from 'node:module';
+import { AST_NODE_KINDS } from './ast.js';
 import { findCycles } from './cycles.js';
 import { findDbPath } from './db.js';
 import { MCP_DEFAULTS, MCP_MAX_LIMIT } from './paginate.js';
-import { ALL_SYMBOL_KINDS, diffImpactMermaid, VALID_ROLES } from './queries.js';
+import { diffImpactMermaid, EVERY_EDGE_KIND, EVERY_SYMBOL_KIND, VALID_ROLES } from './queries.js';
 
 const REPO_PROP = {
   repo: {
@@ -25,23 +26,71 @@ const PAGINATION_PROPS = {
 
 const BASE_TOOLS = [
   {
-    name: 'query_function',
-    description: 'Find callers and callees of a function by name',
+    name: 'query',
+    description:
+      'Query the call graph: find callers/callees with transitive chain, or find shortest path between two symbols',
     inputSchema: {
       type: 'object',
       properties: {
-        name: { type: 'string', description: 'Function name to query (supports partial match)' },
+        name: { type: 'string', description: 'Function/method/class name (partial match)' },
+        mode: {
+          type: 'string',
+          enum: ['deps', 'path'],
+          description: 'deps (default): dependency chain. path: shortest path to target',
+        },
         depth: {
           type: 'number',
-          description: 'Traversal depth for transitive callers',
-          default: 2,
+          description: 'Transitive depth (deps default: 3, path default: 10)',
+        },
+        file: {
+          type: 'string',
+          description: 'Scope search to functions in this file (partial match)',
+        },
+        kind: {
+          type: 'string',
+          enum: EVERY_SYMBOL_KIND,
+          description: 'Filter by symbol kind',
+        },
+        to: { type: 'string', description: 'Target symbol for path mode (required in path mode)' },
+        edge_kinds: {
+          type: 'array',
+          items: { type: 'string', enum: EVERY_EDGE_KIND },
+          description: 'Edge kinds to follow in path mode (default: ["calls"])',
         },
+        reverse: {
+          type: 'boolean',
+          description: 'Follow edges backward in path mode',
+          default: false,
+        },
+        from_file: { type: 'string', description: 'Disambiguate source by file in path mode' },
+        to_file: { type: 'string', description: 'Disambiguate target by file in path mode' },
         no_tests: { type: 'boolean', description: 'Exclude test files', default: false },
         ...PAGINATION_PROPS,
       },
       required: ['name'],
     },
   },
+  {
+    name: 'path',
+    description: 'Find shortest path between two symbols in the dependency graph',
+    inputSchema: {
+      type: 'object',
+      properties: {
+        from: { type: 'string', description: 'Source symbol name' },
+        to: { type: 'string', description: 'Target symbol name' },
+        depth: { type: 'number', description: 'Max traversal depth (default: 10)' },
+        edge_kinds: {
+          type: 'array',
+          items: { type: 'string', enum: EVERY_EDGE_KIND },
+          description: 'Edge kinds to follow (default: ["calls"])',
+        },
+        from_file: { type: 'string', description: 'Disambiguate source by file' },
+        to_file: { type: 'string', description: 'Disambiguate target by file' },
+        no_tests: { type: 'boolean', description: 'Exclude test files', default: false },
+      },
+      required: ['from', 'to'],
+    },
+  },
   {
     name: 'file_deps',
     description: 'Show what a file imports and what imports it',
@@ -55,6 +104,20 @@ const BASE_TOOLS = [
       required: ['file'],
     },
   },
+  {
+    name: 'file_exports',
+    description:
+      'Show exported symbols of a file with per-symbol consumers — who calls each export and from where',
+    inputSchema: {
+      type: 'object',
+      properties: {
+        file: { type: 'string', description: 'File path (partial match supported)' },
+        no_tests: { type: 'boolean', description: 'Exclude test files', default: false },
+        ...PAGINATION_PROPS,
+      },
+      required: ['file'],
+    },
+  },
   {
     name: 'impact_analysis',
     description: 'Show files affected by changes to a given file (transitive)',
@@ -87,29 +150,6 @@ const BASE_TOOLS = [
       },
     },
   },
-  {
-    name: 'fn_deps',
-    description: 'Show function-level dependency chain: what a function calls and what calls it',
-    inputSchema: {
-      type: 'object',
-      properties: {
-        name: { type: 'string', description: 'Function/method/class name (partial match)' },
-        depth: { type: 'number', description: 'Transitive caller depth', default: 3 },
-        file: {
-          type: 'string',
-          description: 'Scope search to functions in this file (partial match)',
-        },
-        kind: {
-          type: 'string',
-          enum: ALL_SYMBOL_KINDS,
-          description: 'Filter to a specific symbol kind',
-        },
-        no_tests: { type: 'boolean', description: 'Exclude test files', default: false },
-        ...PAGINATION_PROPS,
-      },
-      required: ['name'],
-    },
-  },
   {
     name: 'fn_impact',
     description:
@@ -125,7 +165,7 @@ const BASE_TOOLS = [
         },
         kind: {
           type: 'string',
-          enum: ALL_SYMBOL_KINDS,
+          enum: EVERY_SYMBOL_KIND,
           description: 'Filter to a specific symbol kind',
         },
         no_tests: { type: 'boolean', description: 'Exclude test files', default: false },
@@ -134,33 +174,6 @@ const BASE_TOOLS = [
       required: ['name'],
     },
   },
-  {
-    name: 'symbol_path',
-    description: 'Find the shortest path between two symbols in the call graph (A calls...calls B)',
-    inputSchema: {
-      type: 'object',
-      properties: {
-        from: { type: 'string', description: 'Source symbol name (partial match)' },
-        to: { type: 'string', description: 'Target symbol name (partial match)' },
-        max_depth: { type: 'number', description: 'Maximum BFS depth', default: 10 },
-        edge_kinds: {
-          type: 'array',
-          items: { type: 'string' },
-          description: 'Edge kinds to follow (default: ["calls"])',
-        },
-        reverse: { type: 'boolean', description: 'Follow edges backward', default: false },
-        from_file: { type: 'string', description: 'Disambiguate source by file (partial match)' },
-        to_file: { type: 'string', description: 'Disambiguate target by file (partial match)' },
-        kind: {
-          type: 'string',
-          enum: ALL_SYMBOL_KINDS,
-          description: 'Filter both symbols by kind',
-        },
-        no_tests: { type: 'boolean', description: 'Exclude test files', default: false },
-      },
-      required: ['from', 'to'],
-    },
-  },
   {
     name: 'context',
     description:
@@ -180,7 +193,7 @@ const BASE_TOOLS = [
         },
         kind: {
           type: 'string',
-          enum: ALL_SYMBOL_KINDS,
+          enum: EVERY_SYMBOL_KIND,
           description: 'Filter to a specific symbol kind',
         },
         no_source: {
@@ -200,17 +213,19 @@ const BASE_TOOLS = [
     },
   },
   {
-    name: 'explain',
+    name: 'symbol_children',
     description:
-      'Structural summary of a file or function: public/internal API, data flow, dependencies. No LLM needed.',
+      'List sub-declaration children of a symbol: parameters, properties, constants. Answers "what fields does this class have?" without reading source.',
     inputSchema: {
       type: 'object',
       properties: {
-        target: { type: 'string', description: 'File path or function name' },
+        name: { type: 'string', description: 'Function/method/class name (partial match)' },
+        file: { type: 'string', description: 'Scope to file (partial match)' },
+        kind: { type: 'string', enum: EVERY_SYMBOL_KIND, description: 'Filter by symbol kind' },
         no_tests: { type: 'boolean', description: 'Exclude test files', default: false },
         ...PAGINATION_PROPS,
       },
-      required: ['target'],
+      required: ['name'],
     },
   },
   {
@@ -274,13 +289,14 @@ const BASE_TOOLS = [
   },
   {
     name: 'export_graph',
-    description: 'Export the dependency graph in DOT (Graphviz), Mermaid, or JSON format',
+    description:
+      'Export the dependency graph in DOT, Mermaid, JSON, GraphML, GraphSON, or Neo4j CSV format',
     inputSchema: {
       type: 'object',
       properties: {
         format: {
           type: 'string',
-          enum: ['dot', 'mermaid', 'json'],
+          enum: ['dot', 'mermaid', 'json', 'graphml', 'graphson', 'neo4j'],
           description: 'Export format',
         },
         file_level: {
@@ -348,29 +364,6 @@ const BASE_TOOLS = [
       },
     },
   },
-  {
-    name: 'hotspots',
-    description:
-      'Find structural hotspots: files or directories with extreme fan-in, fan-out, or symbol density',
-    inputSchema: {
-      type: 'object',
-      properties: {
-        metric: {
-          type: 'string',
-          enum: ['fan-in', 'fan-out', 'density', 'coupling'],
-          description: 'Metric to rank by',
-        },
-        level: {
-          type: 'string',
-          enum: ['file', 'directory'],
-          description: 'Rank files or directories',
-        },
-        limit: { type: 'number', description: 'Number of results to return', default: 10 },
-        no_tests: { type: 'boolean', description: 'Exclude test files', default: false },
-        offset: { type: 'number', description: 'Skip this many results (pagination, default: 0)' },
-      },
-    },
-  },
   {
     name: 'co_changes',
     description:
@@ -396,14 +389,19 @@ const BASE_TOOLS = [
   {
     name: 'execution_flow',
     description:
-      'Trace execution flow forward from an entry point (route, command, event) through callees to leaf functions. Answers "what happens when X is called?"',
+      'Trace execution flow forward from an entry point through callees to leaves, or list all entry points with list=true',
     inputSchema: {
       type: 'object',
       properties: {
         name: {
           type: 'string',
           description:
-            'Entry point or function name (e.g. "POST /login", "build"). Supports prefix-stripped matching.',
+            'Entry point or function name (required unless list=true). Supports prefix-stripped matching.',
+        },
+        list: {
+          type: 'boolean',
+          description: 'List all entry points grouped by type',
+          default: false,
         },
         depth: { type: 'number', description: 'Max forward traversal depth', default: 10 },
         file: {
@@ -412,25 +410,12 @@ const BASE_TOOLS = [
         },
         kind: {
           type: 'string',
-          enum: ALL_SYMBOL_KINDS,
+          enum: EVERY_SYMBOL_KIND,
           description: 'Filter to a specific symbol kind',
         },
         no_tests: { type: 'boolean', description: 'Exclude test files', default: false },
         ...PAGINATION_PROPS,
       },
-      required: ['name'],
-    },
-  },
-  {
-    name: 'list_entry_points',
-    description:
-      'List all framework entry points (routes, commands, events) in the codebase, grouped by type',
-    inputSchema: {
-      type: 'object',
-      properties: {
-        no_tests: { type: 'boolean', description: 'Exclude test files', default: false },
-        ...PAGINATION_PROPS,
-      },
     },
   },
   {
@@ -468,23 +453,6 @@ const BASE_TOOLS = [
       },
     },
   },
-  {
-    name: 'manifesto',
-    description:
-      'Evaluate manifesto rules and return pass/fail verdicts for code health. Checks function complexity, file metrics, and cycle rules against configured thresholds.',
-    inputSchema: {
-      type: 'object',
-      properties: {
-        file: { type: 'string', description: 'Scope to file (partial match)' },
-        no_tests: { type: 'boolean', description: 'Exclude test files', default: false },
-        kind: {
-          type: 'string',
-          description: 'Filter by symbol kind (function, method, class, etc.)',
-        },
-        ...PAGINATION_PROPS,
-      },
-    },
-  },
   {
     name: 'communities',
     description:
@@ -542,6 +510,11 @@ const BASE_TOOLS = [
       type: 'object',
       properties: {
         target: { type: 'string', description: 'File path or function name' },
+        quick: {
+          type: 'boolean',
+          description: 'Structural summary only (skip impact + health)',
+          default: false,
+        },
         depth: { type: 'number', description: 'Impact analysis depth (default: 3)', default: 3 },
         file: { type: 'string', description: 'Scope to file (partial match)' },
         kind: {
@@ -549,6 +522,7 @@ const BASE_TOOLS = [
           description: 'Filter by symbol kind (function, method, class, etc.)',
         },
         no_tests: { type: 'boolean', description: 'Exclude test files', default: false },
+        ...PAGINATION_PROPS,
       },
       required: ['target'],
     },
@@ -568,10 +542,10 @@ const BASE_TOOLS = [
             'explain',
             'where',
             'query',
-            'fn',
             'impact',
             'deps',
             'flow',
+            'dataflow',
             'complexity',
           ],
           description: 'The query command to run for each target',
@@ -591,7 +565,7 @@ const BASE_TOOLS = [
         },
         kind: {
           type: 'string',
-          enum: ALL_SYMBOL_KINDS,
+          enum: EVERY_SYMBOL_KIND,
           description: 'Filter symbol kind',
         },
         no_tests: { type: 'boolean', description: 'Exclude test files', default: false },
@@ -606,6 +580,12 @@ const BASE_TOOLS = [
     inputSchema: {
       type: 'object',
       properties: {
+        level: {
+          type: 'string',
+          enum: ['function', 'file', 'directory'],
+          description:
+            'Granularity: function (default) | file | directory. File/directory shows hotspots',
+        },
         sort: {
           type: 'string',
           enum: ['risk', 'complexity', 'churn', 'fan-in', 'mi'],
@@ -656,15 +636,60 @@ const BASE_TOOLS = [
       required: ['base', 'target'],
     },
   },
+  {
+    name: 'cfg',
+    description: 'Show intraprocedural control flow graph for a function.',
+    inputSchema: {
+      type: 'object',
+      properties: {
+        name: { type: 'string', description: 'Function/method name (partial match)' },
+        format: {
+          type: 'string',
+          enum: ['json', 'dot', 'mermaid'],
+          description: 'Output format (default: json)',
+        },
+        file: { type: 'string', description: 'Scope to file (partial match)' },
+        kind: { type: 'string', enum: EVERY_SYMBOL_KIND, description: 'Filter by symbol kind' },
+        no_tests: { type: 'boolean', description: 'Exclude test files', default: false },
+        ...PAGINATION_PROPS,
+      },
+      required: ['name'],
+    },
+  },
+  {
+    name: 'dataflow',
+    description: 'Show data flow edges or data-dependent blast radius.',
+    inputSchema: {
+      type: 'object',
+      properties: {
+        name: { type: 'string', description: 'Function/method name (partial match)' },
+        mode: {
+          type: 'string',
+          enum: ['edges', 'impact'],
+          description: 'edges (default) or impact',
+        },
+        depth: { type: 'number', description: 'Max depth for impact mode', default: 5 },
+        file: { type: 'string', description: 'Scope to file (partial match)' },
+        kind: { type: 'string', enum: EVERY_SYMBOL_KIND, description: 'Filter by symbol kind' },
+        no_tests: { type: 'boolean', description: 'Exclude test files', default: false },
+        ...PAGINATION_PROPS,
+      },
+      required: ['name'],
+    },
+  },
   {
     name: 'check',
     description:
-      'Run CI validation predicates against git changes. Checks for new cycles, blast radius violations, signature changes, and boundary violations. Returns pass/fail per predicate — ideal for CI gates.',
+      'CI gate: run manifesto rules (no args), diff predicates (with ref/staged), or both (with rules flag). Returns pass/fail verdicts.',
     inputSchema: {
       type: 'object',
       properties: {
         ref: { type: 'string', description: 'Git ref to diff against (default: HEAD)' },
         staged: { type: 'boolean', description: 'Analyze staged changes instead of unstaged' },
+        rules: {
+          type: 'boolean',
+          description: 'Also run manifesto rules alongside diff predicates',
+        },
         cycles: { type: 'boolean', description: 'Enable cycles predicate (default: true)' },
         blast_radius: {
           type: 'number',
@@ -673,7 +698,35 @@ const BASE_TOOLS = [
         signatures: { type: 'boolean', description: 'Enable signatures predicate (default: true)' },
         boundaries: { type: 'boolean', description: 'Enable boundaries predicate (default: true)' },
         depth: { type: 'number', description: 'Max BFS depth for blast radius (default: 3)' },
+        file: { type: 'string', description: 'Scope to file (partial match, manifesto mode)' },
+        kind: {
+          type: 'string',
+          description: 'Filter by symbol kind (manifesto mode)',
+        },
+        no_tests: { type: 'boolean', description: 'Exclude test files', default: false },
+        ...PAGINATION_PROPS,
+      },
+    },
+  },
+  {
+    name: 'ast_query',
+    description:
+      'Search stored AST nodes (calls, literals, new, throw, await) by pattern. Requires a prior build.',
+    inputSchema: {
+      type: 'object',
+      properties: {
+        pattern: {
+          type: 'string',
+          description: 'GLOB pattern for node name (auto-wrapped in *..* for substring match)',
+        },
+        kind: {
+          type: 'string',
+          enum: AST_NODE_KINDS,
+          description: 'Filter by AST node kind',
+        },
+        file: { type: 'string', description: 'Scope to file (partial match)' },
         no_tests: { type: 'boolean', description: 'Exclude test files', default: false },
+        ...PAGINATION_PROPS,
       },
     },
   },
@@ -743,14 +796,15 @@ export async function startMCPServer(customDbPath, options = {}) {
 
   // Lazy import query functions to avoid circular deps at module load
   const {
-    queryNameData,
     impactAnalysisData,
     moduleMapData,
     fileDepsData,
+    exportsData,
     fnDepsData,
     fnImpactData,
     pathData,
     contextData,
+    childrenData,
     explainData,
     whereData,
     diffImpactData,
@@ -801,11 +855,41 @@ export async function startMCPServer(customDbPath, options = {}) {
 
       let result;
       switch (name) {
-        case 'query_function':
-          result = queryNameData(args.name, dbPath, {
+        case 'query': {
+          const qMode = args.mode || 'deps';
+          if (qMode === 'path') {
+            if (!args.to) {
+              result = { error: 'path mode requires a "to" argument' };
+              break;
+            }
+            result = pathData(args.name, args.to, dbPath, {
+              maxDepth: args.depth ?? 10,
+              edgeKinds: args.edge_kinds,
+              reverse: args.reverse,
+              fromFile: args.from_file,
+              toFile: args.to_file,
+              kind: args.kind,
+              noTests: args.no_tests,
+            });
+          } else {
+            result = fnDepsData(args.name, dbPath, {
+              depth: args.depth,
+              file: args.file,
+              kind: args.kind,
+              noTests: args.no_tests,
+              limit: Math.min(args.limit ?? MCP_DEFAULTS.query, MCP_MAX_LIMIT),
+              offset: args.offset ?? 0,
+            });
+          }
+          break;
+        }
+        case 'path':
+          result = pathData(args.from, args.to, dbPath, {
+            maxDepth: args.depth ?? 10,
+            edgeKinds: args.edge_kinds,
+            fromFile: args.from_file,
+            toFile: args.to_file,
             noTests: args.no_tests,
-            limit: Math.min(args.limit ?? MCP_DEFAULTS.query_function, MCP_MAX_LIMIT),
-            offset: args.offset ?? 0,
           });
           break;
         case 'file_deps':
@@ -815,6 +899,13 @@ export async function startMCPServer(customDbPath, options = {}) {
             offset: args.offset ?? 0,
           });
           break;
+        case 'file_exports':
+          result = exportsData(args.file, dbPath, {
+            noTests: args.no_tests,
+            limit: Math.min(args.limit ?? MCP_DEFAULTS.file_exports, MCP_MAX_LIMIT),
+            offset: args.offset ?? 0,
+          });
+          break;
         case 'impact_analysis':
           result = impactAnalysisData(args.file, dbPath, {
             noTests: args.no_tests,
@@ -832,16 +923,6 @@ export async function startMCPServer(customDbPath, options = {}) {
         case 'module_map':
           result = moduleMapData(dbPath, args.limit || 20, { noTests: args.no_tests });
           break;
-        case 'fn_deps':
-          result = fnDepsData(args.name, dbPath, {
-            depth: args.depth,
-            file: args.file,
-            kind: args.kind,
-            noTests: args.no_tests,
-            limit: Math.min(args.limit ?? MCP_DEFAULTS.fn_deps, MCP_MAX_LIMIT),
-            offset: args.offset ?? 0,
-          });
-          break;
         case 'fn_impact':
           result = fnImpactData(args.name, dbPath, {
             depth: args.depth,
@@ -852,17 +933,6 @@ export async function startMCPServer(customDbPath, options = {}) {
             offset: args.offset ?? 0,
           });
           break;
-        case 'symbol_path':
-          result = pathData(args.from, args.to, dbPath, {
-            maxDepth: args.max_depth,
-            edgeKinds: args.edge_kinds,
-            reverse: args.reverse,
-            fromFile: args.from_file,
-            toFile: args.to_file,
-            kind: args.kind,
-            noTests: args.no_tests,
-          });
-          break;
         case 'context':
           result = contextData(args.name, dbPath, {
             depth: args.depth,
@@ -875,10 +945,12 @@ export async function startMCPServer(customDbPath, options = {}) {
             offset: args.offset ?? 0,
           });
           break;
-        case 'explain':
-          result = explainData(args.target, dbPath, {
+        case 'symbol_children':
+          result = childrenData(args.name, dbPath, {
+            file: args.file,
+            kind: args.kind,
             noTests: args.no_tests,
-            limit: Math.min(args.limit ?? MCP_DEFAULTS.explain, MCP_MAX_LIMIT),
+            limit: Math.min(args.limit ?? MCP_DEFAULTS.context, MCP_MAX_LIMIT),
             offset: args.offset ?? 0,
           });
           break;
@@ -967,7 +1039,14 @@ export async function startMCPServer(customDbPath, options = {}) {
           break;
         }
         case 'export_graph': {
-          const { exportDOT, exportMermaid, exportJSON } = await import('./export.js');
+          const {
+            exportDOT,
+            exportGraphML,
+            exportGraphSON,
+            exportJSON,
+            exportMermaid,
+            exportNeo4jCSV,
+          } = await import('./export.js');
           const db = new Database(findDbPath(dbPath), { readonly: true });
           const fileLevel = args.file_level !== false;
           const exportLimit = args.limit
@@ -986,13 +1065,26 @@ export async function startMCPServer(customDbPath, options = {}) {
                 offset: args.offset ?? 0,
               });
               break;
+            case 'graphml':
+              result = exportGraphML(db, { fileLevel, limit: exportLimit });
+              break;
+            case 'graphson':
+              result = exportGraphSON(db, {
+                fileLevel,
+                limit: exportLimit,
+                offset: args.offset ?? 0,
+              });
+              break;
+            case 'neo4j':
+              result = exportNeo4jCSV(db, { fileLevel, limit: exportLimit });
+              break;
             default:
               db.close();
               return {
                 content: [
                   {
                     type: 'text',
-                    text: `Unknown format: ${args.format}. Use dot, mermaid, or json.`,
+                    text: `Unknown format: ${args.format}. Use dot, mermaid, json, graphml, graphson, or neo4j.`,
                   },
                 ],
                 isError: true,
@@ -1031,17 +1123,6 @@ export async function startMCPServer(customDbPath, options = {}) {
           });
           break;
         }
-        case 'hotspots': {
-          const { hotspotsData } = await import('./structure.js');
-          result = hotspotsData(dbPath, {
-            metric: args.metric,
-            level: args.level,
-            limit: Math.min(args.limit ?? MCP_DEFAULTS.hotspots, MCP_MAX_LIMIT),
-            offset: args.offset ?? 0,
-            noTests: args.no_tests,
-          });
-          break;
-        }
         case 'co_changes': {
           const { coChangeData, coChangeTopData } = await import('./cochange.js');
           result = args.file
@@ -1060,24 +1141,28 @@ export async function startMCPServer(customDbPath, options = {}) {
           break;
         }
         case 'execution_flow': {
-          const { flowData } = await import('./flow.js');
-          result = flowData(args.name, dbPath, {
-            depth: args.depth,
-            file: args.file,
-            kind: args.kind,
-            noTests: args.no_tests,
-            limit: Math.min(args.limit ?? MCP_DEFAULTS.execution_flow, MCP_MAX_LIMIT),
-            offset: args.offset ?? 0,
-          });
-          break;
-        }
-        case 'list_entry_points': {
-          const { listEntryPointsData } = await import('./flow.js');
-          result = listEntryPointsData(dbPath, {
-            noTests: args.no_tests,
-            limit: Math.min(args.limit ?? MCP_DEFAULTS.list_entry_points, MCP_MAX_LIMIT),
-            offset: args.offset ?? 0,
-          });
+          if (args.list) {
+            const { listEntryPointsData } = await import('./flow.js');
+            result = listEntryPointsData(dbPath, {
+              noTests: args.no_tests,
+              limit: Math.min(args.limit ?? MCP_DEFAULTS.execution_flow, MCP_MAX_LIMIT),
+              offset: args.offset ?? 0,
+            });
+          } else {
+            if (!args.name) {
+              result = { error: 'Provide a name or set list=true' };
+              break;
+            }
+            const { flowData } = await import('./flow.js');
+            result = flowData(args.name, dbPath, {
+              depth: args.depth,
+              file: args.file,
+              kind: args.kind,
+              noTests: args.no_tests,
+              limit: Math.min(args.limit ?? MCP_DEFAULTS.execution_flow, MCP_MAX_LIMIT),
+              offset: args.offset ?? 0,
+            });
+          }
           break;
         }
         case 'complexity': {
@@ -1095,17 +1180,6 @@ export async function startMCPServer(customDbPath, options = {}) {
           });
           break;
         }
-        case 'manifesto': {
-          const { manifestoData } = await import('./manifesto.js');
-          result = manifestoData(dbPath, {
-            file: args.file,
-            noTests: args.no_tests,
-            kind: args.kind,
-            limit: Math.min(args.limit ?? MCP_DEFAULTS.manifesto, MCP_MAX_LIMIT),
-            offset: args.offset ?? 0,
-          });
-          break;
-        }
         case 'communities': {
           const { communitiesData } = await import('./communities.js');
           result = communitiesData(dbPath, {
@@ -1130,13 +1204,21 @@ export async function startMCPServer(customDbPath, options = {}) {
           break;
         }
         case 'audit': {
-          const { auditData } = await import('./audit.js');
-          result = auditData(args.target, dbPath, {
-            depth: args.depth,
-            file: args.file,
-            kind: args.kind,
-            noTests: args.no_tests,
-          });
+          if (args.quick) {
+            result = explainData(args.target, dbPath, {
+              noTests: args.no_tests,
+              limit: Math.min(args.limit ?? MCP_DEFAULTS.explain, MCP_MAX_LIMIT),
+              offset: args.offset ?? 0,
+            });
+          } else {
+            const { auditData } = await import('./audit.js');
+            result = auditData(args.target, dbPath, {
+              depth: args.depth,
+              file: args.file,
+              kind: args.kind,
+              noTests: args.no_tests,
+            });
+          }
           break;
         }
         case 'batch_query': {
@@ -1150,18 +1232,36 @@ export async function startMCPServer(customDbPath, options = {}) {
           break;
         }
         case 'triage': {
-          const { triageData } = await import('./triage.js');
-          result = triageData(dbPath, {
-            sort: args.sort,
-            minScore: args.min_score,
-            role: args.role,
-            file: args.file,
-            kind: args.kind,
-            noTests: args.no_tests,
-            weights: args.weights,
-            limit: Math.min(args.limit ?? MCP_DEFAULTS.triage, MCP_MAX_LIMIT),
-            offset: args.offset ?? 0,
-          });
+          if (args.level === 'file' || args.level === 'directory') {
+            const { hotspotsData } = await import('./structure.js');
+            const TRIAGE_TO_HOTSPOT = {
+              risk: 'fan-in',
+              complexity: 'density',
+              churn: 'coupling',
+              mi: 'fan-in',
+            };
+            const metric = TRIAGE_TO_HOTSPOT[args.sort] ?? args.sort;
+            result = hotspotsData(dbPath, {
+              metric,
+              level: args.level,
+              limit: Math.min(args.limit ?? MCP_DEFAULTS.hotspots, MCP_MAX_LIMIT),
+              offset: args.offset ?? 0,
+              noTests: args.no_tests,
+            });
+          } else {
+            const { triageData } = await import('./triage.js');
+            result = triageData(dbPath, {
+              sort: args.sort,
+              minScore: args.min_score,
+              role: args.role,
+              file: args.file,
+              kind: args.kind,
+              noTests: args.no_tests,
+              weights: args.weights,
+              limit: Math.min(args.limit ?? MCP_DEFAULTS.triage, MCP_MAX_LIMIT),
+              offset: args.offset ?? 0,
+            });
+          }
           break;
         }
         case 'branch_compare': {
@@ -1173,17 +1273,98 @@ export async function startMCPServer(customDbPath, options = {}) {
           result = args.format === 'mermaid' ? branchCompareMermaid(bcData) : bcData;
           break;
         }
+        case 'cfg': {
+          const { cfgData, cfgToDOT, cfgToMermaid } = await import('./cfg.js');
+          const cfgResult = cfgData(args.name, dbPath, {
+            file: args.file,
+            kind: args.kind,
+            noTests: args.no_tests,
+            limit: Math.min(args.limit ?? MCP_DEFAULTS.query, MCP_MAX_LIMIT),
+            offset: args.offset ?? 0,
+          });
+          if (args.format === 'dot') {
+            result = { text: cfgToDOT(cfgResult) };
+          } else if (args.format === 'mermaid') {
+            result = { text: cfgToMermaid(cfgResult) };
+          } else {
+            result = cfgResult;
+          }
+          break;
+        }
+        case 'dataflow': {
+          const dfMode = args.mode || 'edges';
+          if (dfMode === 'impact') {
+            const { dataflowImpactData } = await import('./dataflow.js');
+            result = dataflowImpactData(args.name, dbPath, {
+              depth: args.depth,
+              file: args.file,
+              kind: args.kind,
+              noTests: args.no_tests,
+              limit: Math.min(args.limit ?? MCP_DEFAULTS.fn_impact, MCP_MAX_LIMIT),
+              offset: args.offset ?? 0,
+            });
+          } else {
+            const { dataflowData } = await import('./dataflow.js');
+            result = dataflowData(args.name, dbPath, {
+              file: args.file,
+              kind: args.kind,
+              noTests: args.no_tests,
+              limit: Math.min(args.limit ?? MCP_DEFAULTS.query, MCP_MAX_LIMIT),
+              offset: args.offset ?? 0,
+            });
+          }
+          break;
+        }
         case 'check': {
-          const { checkData } = await import('./check.js');
-          result = checkData(dbPath, {
-            ref: args.ref,
-            staged: args.staged,
-            cycles: args.cycles,
-            blastRadius: args.blast_radius,
-            signatures: args.signatures,
-            boundaries: args.boundaries,
-            depth: args.depth,
+          const isDiffMode = args.ref || args.staged;
+
+          if (!isDiffMode && !args.rules) {
+            // No ref, no staged → run manifesto rules on whole codebase
+            const { manifestoData } = await import('./manifesto.js');
+            result = manifestoData(dbPath, {
+              file: args.file,
+              noTests: args.no_tests,
+              kind: args.kind,
+              limit: Math.min(args.limit ?? MCP_DEFAULTS.manifesto, MCP_MAX_LIMIT),
+              offset: args.offset ?? 0,
+            });
+          } else {
+            const { checkData } = await import('./check.js');
+            const checkResult = checkData(dbPath, {
+              ref: args.ref,
+              staged: args.staged,
+              cycles: args.cycles,
+              blastRadius: args.blast_radius,
+              signatures: args.signatures,
+              boundaries: args.boundaries,
+              depth: args.depth,
+              noTests: args.no_tests,
+            });
+
+            if (args.rules) {
+              const { manifestoData } = await import('./manifesto.js');
+              const manifestoResult = manifestoData(dbPath, {
+                file: args.file,
+                noTests: args.no_tests,
+                kind: args.kind,
+                limit: Math.min(args.limit ?? MCP_DEFAULTS.manifesto, MCP_MAX_LIMIT),
+                offset: args.offset ?? 0,
+              });
+              result = { check: checkResult, manifesto: manifestoResult };
+            } else {
+              result = checkResult;
+            }
+          }
+          break;
+        }
+        case 'ast_query': {
+          const { astQueryData } = await import('./ast.js');
+          result = astQueryData(args.pattern, dbPath, {
+            kind: args.kind,
+            file: args.file,
             noTests: args.no_tests,
+            limit: Math.min(args.limit ?? MCP_DEFAULTS.ast_query, MCP_MAX_LIMIT),
+            offset: args.offset ?? 0,
           });
           break;
         }