@optave/codegraph 3.1.3 → 3.1.4

package/src/mcp/tools/ast-query.js

@@ -0,0 +1,14 @@
+import { effectiveLimit, effectiveOffset } from '../middleware.js';
+
+export const name = 'ast_query';
+
+export async function handler(args, ctx) {
+  const { astQueryData } = await import('../../ast.js');
+  return astQueryData(args.pattern, ctx.dbPath, {
+    kind: args.kind,
+    file: args.file,
+    noTests: args.no_tests,
+    limit: effectiveLimit(args, name),
+    offset: effectiveOffset(args),
+  });
+}

package/src/mcp/tools/audit.js

@@ -0,0 +1,21 @@
+import { effectiveOffset, MCP_DEFAULTS, MCP_MAX_LIMIT } from '../middleware.js';
+
+export const name = 'audit';
+
+export async function handler(args, ctx) {
+  if (args.quick) {
+    const { explainData } = await ctx.getQueries();
+    return explainData(args.target, ctx.dbPath, {
+      noTests: args.no_tests,
+      limit: Math.min(args.limit ?? MCP_DEFAULTS.explain, MCP_MAX_LIMIT),
+      offset: effectiveOffset(args),
+    });
+  }
+  const { auditData } = await import('../../audit.js');
+  return auditData(args.target, ctx.dbPath, {
+    depth: args.depth,
+    file: args.file,
+    kind: args.kind,
+    noTests: args.no_tests,
+  });
+}

package/src/mcp/tools/batch-query.js

@@ -0,0 +1,11 @@
+export const name = 'batch_query';
+
+export async function handler(args, ctx) {
+  const { batchData } = await import('../../batch.js');
+  return batchData(args.command, args.targets, ctx.dbPath, {
+    depth: args.depth,
+    file: args.file,
+    kind: args.kind,
+    noTests: args.no_tests,
+  });
+}

package/src/mcp/tools/branch-compare.js

@@ -0,0 +1,10 @@
+export const name = 'branch_compare';
+
+export async function handler(args, _ctx) {
+  const { branchCompareData, branchCompareMermaid } = await import('../../branch-compare.js');
+  const bcData = await branchCompareData(args.base, args.target, {
+    depth: args.depth,
+    noTests: args.no_tests,
+  });
+  return args.format === 'mermaid' ? branchCompareMermaid(bcData) : bcData;
+}

package/src/mcp/tools/cfg.js

@@ -0,0 +1,21 @@
+import { effectiveOffset, MCP_DEFAULTS } from '../middleware.js';
+
+export const name = 'cfg';
+
+export async function handler(args, ctx) {
+  const { cfgData, cfgToDOT, cfgToMermaid } = await import('../../cfg.js');
+  const cfgResult = cfgData(args.name, ctx.dbPath, {
+    file: args.file,
+    kind: args.kind,
+    noTests: args.no_tests,
+    limit: Math.min(args.limit ?? MCP_DEFAULTS.query, ctx.MCP_MAX_LIMIT),
+    offset: effectiveOffset(args),
+  });
+  if (args.format === 'dot') {
+    return { text: cfgToDOT(cfgResult) };
+  }
+  if (args.format === 'mermaid') {
+    return { text: cfgToMermaid(cfgResult) };
+  }
+  return cfgResult;
+}

package/src/mcp/tools/check.js

@@ -0,0 +1,43 @@
+import { effectiveOffset, MCP_DEFAULTS, MCP_MAX_LIMIT } from '../middleware.js';
+
+export const name = 'check';
+
+export async function handler(args, ctx) {
+  const isDiffMode = args.ref || args.staged;
+
+  if (!isDiffMode && !args.rules) {
+    const { manifestoData } = await import('../../manifesto.js');
+    return manifestoData(ctx.dbPath, {
+      file: args.file,
+      noTests: args.no_tests,
+      kind: args.kind,
+      limit: Math.min(args.limit ?? MCP_DEFAULTS.manifesto, MCP_MAX_LIMIT),
+      offset: effectiveOffset(args),
+    });
+  }
+
+  const { checkData } = await import('../../check.js');
+  const checkResult = checkData(ctx.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(ctx.dbPath, {
+      file: args.file,
+      noTests: args.no_tests,
+      kind: args.kind,
+      limit: Math.min(args.limit ?? MCP_DEFAULTS.manifesto, MCP_MAX_LIMIT),
+      offset: effectiveOffset(args),
+    });
+    return { check: checkResult, manifesto: manifestoResult };
+  }
+  return checkResult;
+}

package/src/mcp/tools/co-changes.js

@@ -0,0 +1,20 @@
+import { effectiveLimit, effectiveOffset } from '../middleware.js';
+
+export const name = 'co_changes';
+
+export async function handler(args, ctx) {
+  const { coChangeData, coChangeTopData } = await import('../../cochange.js');
+  return args.file
+    ? coChangeData(args.file, ctx.dbPath, {
+        limit: effectiveLimit(args, name),
+        offset: effectiveOffset(args),
+        minJaccard: args.min_jaccard,
+        noTests: args.no_tests,
+      })
+    : coChangeTopData(ctx.dbPath, {
+        limit: effectiveLimit(args, name),
+        offset: effectiveOffset(args),
+        minJaccard: args.min_jaccard,
+        noTests: args.no_tests,
+      });
+}

package/src/mcp/tools/code-owners.js

@@ -0,0 +1,12 @@
+export const name = 'code_owners';
+
+export async function handler(args, ctx) {
+  const { ownersData } = await import('../../owners.js');
+  return ownersData(ctx.dbPath, {
+    file: args.file,
+    owner: args.owner,
+    boundary: args.boundary,
+    kind: args.kind,
+    noTests: args.no_tests,
+  });
+}

package/src/mcp/tools/communities.js

@@ -0,0 +1,15 @@
+import { effectiveLimit, effectiveOffset } from '../middleware.js';
+
+export const name = 'communities';
+
+export async function handler(args, ctx) {
+  const { communitiesData } = await import('../../communities.js');
+  return communitiesData(ctx.dbPath, {
+    functions: args.functions,
+    resolution: args.resolution,
+    drift: args.drift,
+    noTests: args.no_tests,
+    limit: effectiveLimit(args, name),
+    offset: effectiveOffset(args),
+  });
+}

package/src/mcp/tools/complexity.js

@@ -0,0 +1,18 @@
+import { effectiveLimit, effectiveOffset } from '../middleware.js';
+
+export const name = 'complexity';
+
+export async function handler(args, ctx) {
+  const { complexityData } = await import('../../complexity.js');
+  return complexityData(ctx.dbPath, {
+    target: args.name,
+    file: args.file,
+    limit: effectiveLimit(args, name),
+    offset: effectiveOffset(args),
+    sort: args.sort,
+    aboveThreshold: args.above_threshold,
+    health: args.health,
+    noTests: args.no_tests,
+    kind: args.kind,
+  });
+}

package/src/mcp/tools/context.js

@@ -0,0 +1,17 @@
+import { effectiveLimit, effectiveOffset } from '../middleware.js';
+
+export const name = 'context';
+
+export async function handler(args, ctx) {
+  const { contextData } = await ctx.getQueries();
+  return contextData(args.name, ctx.dbPath, {
+    depth: args.depth,
+    file: args.file,
+    kind: args.kind,
+    noSource: args.no_source,
+    noTests: args.no_tests,
+    includeTests: args.include_tests,
+    limit: effectiveLimit(args, name),
+    offset: effectiveOffset(args),
+  });
+}

package/src/mcp/tools/dataflow.js

@@ -0,0 +1,26 @@
+import { effectiveOffset, MCP_DEFAULTS } from '../middleware.js';
+
+export const name = 'dataflow';
+
+export async function handler(args, ctx) {
+  const dfMode = args.mode || 'edges';
+  if (dfMode === 'impact') {
+    const { dataflowImpactData } = await import('../../dataflow.js');
+    return dataflowImpactData(args.name, ctx.dbPath, {
+      depth: args.depth,
+      file: args.file,
+      kind: args.kind,
+      noTests: args.no_tests,
+      limit: Math.min(args.limit ?? MCP_DEFAULTS.fn_impact, ctx.MCP_MAX_LIMIT),
+      offset: effectiveOffset(args),
+    });
+  }
+  const { dataflowData } = await import('../../dataflow.js');
+  return dataflowData(args.name, ctx.dbPath, {
+    file: args.file,
+    kind: args.kind,
+    noTests: args.no_tests,
+    limit: Math.min(args.limit ?? MCP_DEFAULTS.query, ctx.MCP_MAX_LIMIT),
+    offset: effectiveOffset(args),
+  });
+}

package/src/mcp/tools/diff-impact.js

@@ -0,0 +1,24 @@
+import { effectiveLimit, effectiveOffset } from '../middleware.js';
+
+export const name = 'diff_impact';
+
+export async function handler(args, ctx) {
+  if (args.format === 'mermaid') {
+    const { diffImpactMermaid } = await ctx.getQueries();
+    return diffImpactMermaid(ctx.dbPath, {
+      staged: args.staged,
+      ref: args.ref,
+      depth: args.depth,
+      noTests: args.no_tests,
+    });
+  }
+  const { diffImpactData } = await ctx.getQueries();
+  return diffImpactData(ctx.dbPath, {
+    staged: args.staged,
+    ref: args.ref,
+    depth: args.depth,
+    noTests: args.no_tests,
+    limit: effectiveLimit(args, name),
+    offset: effectiveOffset(args),
+  });
+}

package/src/mcp/tools/execution-flow.js

@@ -0,0 +1,26 @@
+import { effectiveLimit, effectiveOffset } from '../middleware.js';
+
+export const name = 'execution_flow';
+
+export async function handler(args, ctx) {
+  if (args.list) {
+    const { listEntryPointsData } = await import('../../flow.js');
+    return listEntryPointsData(ctx.dbPath, {
+      noTests: args.no_tests,
+      limit: effectiveLimit(args, name),
+      offset: effectiveOffset(args),
+    });
+  }
+  if (!args.name) {
+    return { error: 'Provide a name or set list=true' };
+  }
+  const { flowData } = await import('../../flow.js');
+  return flowData(args.name, ctx.dbPath, {
+    depth: args.depth,
+    file: args.file,
+    kind: args.kind,
+    noTests: args.no_tests,
+    limit: effectiveLimit(args, name),
+    offset: effectiveOffset(args),
+  });
+}

package/src/mcp/tools/export-graph.js

@@ -0,0 +1,57 @@
+import { findDbPath } from '../../db.js';
+import { effectiveOffset, MCP_DEFAULTS, MCP_MAX_LIMIT } from '../middleware.js';
+
+export const name = 'export_graph';
+
+export async function handler(args, ctx) {
+  const { exportDOT, exportGraphML, exportGraphSON, exportJSON, exportMermaid, exportNeo4jCSV } =
+    await import('../../export.js');
+  const Database = ctx.getDatabase();
+  const db = new Database(findDbPath(ctx.dbPath), { readonly: true });
+  const fileLevel = args.file_level !== false;
+  const exportLimit = args.limit ? Math.min(args.limit, MCP_MAX_LIMIT) : MCP_DEFAULTS.export_graph;
+
+  let result;
+  try {
+    switch (args.format) {
+      case 'dot':
+        result = exportDOT(db, { fileLevel, limit: exportLimit });
+        break;
+      case 'mermaid':
+        result = exportMermaid(db, { fileLevel, limit: exportLimit });
+        break;
+      case 'json':
+        result = exportJSON(db, {
+          limit: exportLimit,
+          offset: effectiveOffset(args),
+        });
+        break;
+      case 'graphml':
+        result = exportGraphML(db, { fileLevel, limit: exportLimit });
+        break;
+      case 'graphson':
+        result = exportGraphSON(db, {
+          fileLevel,
+          limit: exportLimit,
+          offset: effectiveOffset(args),
+        });
+        break;
+      case 'neo4j':
+        result = exportNeo4jCSV(db, { fileLevel, limit: exportLimit });
+        break;
+      default:
+        return {
+          content: [
+            {
+              type: 'text',
+              text: `Unknown format: ${args.format}. Use dot, mermaid, json, graphml, graphson, or neo4j.`,
+            },
+          ],
+          isError: true,
+        };
+    }
+  } finally {
+    db.close();
+  }
+  return result;
+}

package/src/mcp/tools/file-deps.js

@@ -0,0 +1,12 @@
+import { effectiveLimit, effectiveOffset } from '../middleware.js';
+
+export const name = 'file_deps';
+
+export async function handler(args, ctx) {
+  const { fileDepsData } = await ctx.getQueries();
+  return fileDepsData(args.file, ctx.dbPath, {
+    noTests: args.no_tests,
+    limit: effectiveLimit(args, name),
+    offset: effectiveOffset(args),
+  });
+}

package/src/mcp/tools/file-exports.js

@@ -0,0 +1,13 @@
+import { effectiveLimit, effectiveOffset } from '../middleware.js';
+
+export const name = 'file_exports';
+
+export async function handler(args, ctx) {
+  const { exportsData } = await ctx.getQueries();
+  return exportsData(args.file, ctx.dbPath, {
+    noTests: args.no_tests,
+    unused: args.unused,
+    limit: effectiveLimit(args, name),
+    offset: effectiveOffset(args),
+  });
+}

package/src/mcp/tools/find-cycles.js

@@ -0,0 +1,15 @@
+import { findCycles } from '../../cycles.js';
+import { findDbPath } from '../../db.js';
+
+export const name = 'find_cycles';
+
+export async function handler(_args, ctx) {
+  const Database = ctx.getDatabase();
+  const db = new Database(findDbPath(ctx.dbPath), { readonly: true });
+  try {
+    const cycles = findCycles(db);
+    return { cycles, count: cycles.length };
+  } finally {
+    db.close();
+  }
+}

package/src/mcp/tools/fn-impact.js

@@ -0,0 +1,15 @@
+import { effectiveLimit, effectiveOffset } from '../middleware.js';
+
+export const name = 'fn_impact';
+
+export async function handler(args, ctx) {
+  const { fnImpactData } = await ctx.getQueries();
+  return fnImpactData(args.name, ctx.dbPath, {
+    depth: args.depth,
+    file: args.file,
+    kind: args.kind,
+    noTests: args.no_tests,
+    limit: effectiveLimit(args, name),
+    offset: effectiveOffset(args),
+  });
+}

package/src/mcp/tools/impact-analysis.js

@@ -0,0 +1,12 @@
+import { effectiveLimit, effectiveOffset } from '../middleware.js';
+
+export const name = 'impact_analysis';
+
+export async function handler(args, ctx) {
+  const { impactAnalysisData } = await ctx.getQueries();
+  return impactAnalysisData(args.file, ctx.dbPath, {
+    noTests: args.no_tests,
+    limit: effectiveLimit(args, name),
+    offset: effectiveOffset(args),
+  });
+}

package/src/mcp/tools/index.js

@@ -0,0 +1,71 @@
+/**
+ * Barrel module — registers all MCP tool handlers.
+ */
+
+import * as astQuery from './ast-query.js';
+import * as audit from './audit.js';
+import * as batchQuery from './batch-query.js';
+import * as branchCompare from './branch-compare.js';
+import * as cfg from './cfg.js';
+import * as check from './check.js';
+import * as coChanges from './co-changes.js';
+import * as codeOwners from './code-owners.js';
+import * as communities from './communities.js';
+import * as complexity from './complexity.js';
+import * as context from './context.js';
+import * as dataflow from './dataflow.js';
+import * as diffImpact from './diff-impact.js';
+import * as executionFlow from './execution-flow.js';
+import * as exportGraph from './export-graph.js';
+import * as fileDeps from './file-deps.js';
+import * as fileExports from './file-exports.js';
+import * as findCycles from './find-cycles.js';
+import * as fnImpact from './fn-impact.js';
+import * as impactAnalysis from './impact-analysis.js';
+import * as listFunctions from './list-functions.js';
+import * as listRepos from './list-repos.js';
+import * as moduleMap from './module-map.js';
+import * as nodeRoles from './node-roles.js';
+import * as path from './path.js';
+import * as query from './query.js';
+import * as semanticSearch from './semantic-search.js';
+import * as sequence from './sequence.js';
+import * as structure from './structure.js';
+import * as symbolChildren from './symbol-children.js';
+import * as triage from './triage.js';
+import * as where from './where.js';
+
+export const TOOL_HANDLERS = new Map([
+  [query.name, query],
+  [path.name, path],
+  [fileDeps.name, fileDeps],
+  [fileExports.name, fileExports],
+  [impactAnalysis.name, impactAnalysis],
+  [findCycles.name, findCycles],
+  [moduleMap.name, moduleMap],
+  [fnImpact.name, fnImpact],
+  [context.name, context],
+  [symbolChildren.name, symbolChildren],
+  [where.name, where],
+  [diffImpact.name, diffImpact],
+  [semanticSearch.name, semanticSearch],
+  [exportGraph.name, exportGraph],
+  [listFunctions.name, listFunctions],
+  [structure.name, structure],
+  [nodeRoles.name, nodeRoles],
+  [coChanges.name, coChanges],
+  [executionFlow.name, executionFlow],
+  [sequence.name, sequence],
+  [complexity.name, complexity],
+  [communities.name, communities],
+  [codeOwners.name, codeOwners],
+  [audit.name, audit],
+  [batchQuery.name, batchQuery],
+  [triage.name, triage],
+  [branchCompare.name, branchCompare],
+  [cfg.name, cfg],
+  [dataflow.name, dataflow],
+  [check.name, check],
+  [astQuery.name, astQuery],
+  [listRepos.name, listRepos],
+]);

package/src/mcp/tools/list-functions.js

@@ -0,0 +1,14 @@
+import { effectiveLimit, effectiveOffset } from '../middleware.js';
+
+export const name = 'list_functions';
+
+export async function handler(args, ctx) {
+  const { listFunctionsData } = await ctx.getQueries();
+  return listFunctionsData(ctx.dbPath, {
+    file: args.file,
+    pattern: args.pattern,
+    noTests: args.no_tests,
+    limit: effectiveLimit(args, name),
+    offset: effectiveOffset(args),
+  });
+}

package/src/mcp/tools/list-repos.js

@@ -0,0 +1,11 @@
+export const name = 'list_repos';
+
+export async function handler(_args, ctx) {
+  const { listRepos, pruneRegistry } = await import('../../registry.js');
+  pruneRegistry();
+  let repos = listRepos();
+  if (ctx.allowedRepos) {
+    repos = repos.filter((r) => ctx.allowedRepos.includes(r.name));
+  }
+  return { repos };
+}

package/src/mcp/tools/module-map.js

@@ -0,0 +1,6 @@
+export const name = 'module_map';
+
+export async function handler(args, ctx) {
+  const { moduleMapData } = await ctx.getQueries();
+  return moduleMapData(ctx.dbPath, args.limit || 20, { noTests: args.no_tests });
+}

package/src/mcp/tools/node-roles.js

@@ -0,0 +1,14 @@
+import { effectiveLimit, effectiveOffset } from '../middleware.js';
+
+export const name = 'node_roles';
+
+export async function handler(args, ctx) {
+  const { rolesData } = await ctx.getQueries();
+  return rolesData(ctx.dbPath, {
+    role: args.role,
+    file: args.file,
+    noTests: args.no_tests,
+    limit: effectiveLimit(args, name),
+    offset: effectiveOffset(args),
+  });
+}

package/src/mcp/tools/path.js

@@ -0,0 +1,12 @@
+export const name = 'path';
+
+export async function handler(args, ctx) {
+  const { pathData } = await ctx.getQueries();
+  return pathData(args.from, args.to, ctx.dbPath, {
+    maxDepth: args.depth ?? 10,
+    edgeKinds: args.edge_kinds,
+    fromFile: args.from_file,
+    toFile: args.to_file,
+    noTests: args.no_tests,
+  });
+}

package/src/mcp/tools/query.js

@@ -0,0 +1,30 @@
+import { effectiveOffset, MCP_DEFAULTS } from '../middleware.js';
+
+export const name = 'query';
+
+export async function handler(args, ctx) {
+  const { fnDepsData, pathData } = await ctx.getQueries();
+  const qMode = args.mode || 'deps';
+  if (qMode === 'path') {
+    if (!args.to) {
+      return { error: 'path mode requires a "to" argument' };
+    }
+    return pathData(args.name, args.to, ctx.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,
+    });
+  }
+  return fnDepsData(args.name, ctx.dbPath, {
+    depth: args.depth,
+    file: args.file,
+    kind: args.kind,
+    noTests: args.no_tests,
+    limit: Math.min(args.limit ?? MCP_DEFAULTS.query, ctx.MCP_MAX_LIMIT),
+    offset: effectiveOffset(args),
+  });
+}

package/src/mcp/tools/semantic-search.js

@@ -0,0 +1,65 @@
+import { effectiveOffset, MCP_DEFAULTS, MCP_MAX_LIMIT } from '../middleware.js';
+
+export const name = 'semantic_search';
+
+export async function handler(args, ctx) {
+  const mode = args.mode || 'hybrid';
+  const searchOpts = {
+    limit: Math.min(args.limit ?? MCP_DEFAULTS.semantic_search, MCP_MAX_LIMIT),
+    offset: effectiveOffset(args),
+    minScore: args.min_score,
+  };
+
+  if (mode === 'keyword') {
+    const { ftsSearchData } = await import('../../embeddings/index.js');
+    const result = ftsSearchData(args.query, ctx.dbPath, searchOpts);
+    if (result === null) {
+      return {
+        content: [
+          {
+            type: 'text',
+            text: 'No FTS5 index found. Run `codegraph embed` to build the keyword index.',
+          },
+        ],
+        isError: true,
+      };
+    }
+    return result;
+  }
+
+  if (mode === 'semantic') {
+    const { searchData } = await import('../../embeddings/index.js');
+    const result = await searchData(args.query, ctx.dbPath, searchOpts);
+    if (result === null) {
+      return {
+        content: [
+          {
+            type: 'text',
+            text: 'Semantic search unavailable. Run `codegraph embed` first.',
+          },
+        ],
+        isError: true,
+      };
+    }
+    return result;
+  }
+
+  // hybrid (default) — falls back to semantic if no FTS5
+  const { hybridSearchData, searchData } = await import('../../embeddings/index.js');
+  let result = await hybridSearchData(args.query, ctx.dbPath, searchOpts);
+  if (result === null) {
+    result = await searchData(args.query, ctx.dbPath, searchOpts);
+    if (result === null) {
+      return {
+        content: [
+          {
+            type: 'text',
+            text: 'Semantic search unavailable. Run `codegraph embed` first.',
+          },
+        ],
+        isError: true,
+      };
+    }
+  }
+  return result;
+}