optave-codegraph 3.13.0

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

@@ -0,0 +1,25 @@
+import type { ASTNodeKind } from '../../types.js';
+import { effectiveLimit, effectiveOffset } from '../middleware.js';
+import type { McpToolContext } from '../types.js';
+
+export const name = 'ast_query';
+
+interface AstQueryArgs {
+  pattern?: string;
+  kind?: ASTNodeKind;
+  file?: string;
+  no_tests?: boolean;
+  limit?: number;
+  offset?: number;
+}
+
+export async function handler(args: AstQueryArgs, ctx: McpToolContext): Promise<unknown> {
+  const { astQueryData } = await import('../../features/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.ts

@@ -0,0 +1,33 @@
+import { effectiveOffset, MCP_DEFAULTS, MCP_MAX_LIMIT } from '../middleware.js';
+import type { McpToolContext } from '../types.js';
+
+export const name = 'audit';
+
+interface AuditArgs {
+  target: string;
+  quick?: boolean;
+  depth?: number;
+  file?: string;
+  kind?: string;
+  no_tests?: boolean;
+  limit?: number;
+  offset?: number;
+}
+
+export async function handler(args: AuditArgs, ctx: McpToolContext): Promise<unknown> {
+  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 ?? 100, MCP_MAX_LIMIT),
+      offset: effectiveOffset(args),
+    });
+  }
+  const { auditData } = await import('../../features/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.ts

@@ -0,0 +1,22 @@
+import type { McpToolContext } from '../types.js';
+
+export const name = 'batch_query';
+
+interface BatchQueryArgs {
+  command: string;
+  targets: string[];
+  depth?: number;
+  file?: string;
+  kind?: string;
+  no_tests?: boolean;
+}
+
+export async function handler(args: BatchQueryArgs, ctx: McpToolContext): Promise<unknown> {
+  const { batchData } = await import('../../features/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.ts

@@ -0,0 +1,22 @@
+import type { McpToolContext } from '../types.js';
+
+export const name = 'branch_compare';
+
+interface BranchCompareArgs {
+  base: string;
+  target: string;
+  depth?: number;
+  no_tests?: boolean;
+  format?: 'json' | 'mermaid';
+}
+
+export async function handler(args: BranchCompareArgs, _ctx: McpToolContext): Promise<unknown> {
+  const { branchCompareData, branchCompareMermaid } = await import(
+    '../../features/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/brief.ts

@@ -0,0 +1,15 @@
+import type { McpToolContext } from '../types.js';
+
+export const name = 'brief';
+
+interface BriefArgs {
+  file: string;
+  no_tests?: boolean;
+}
+
+export async function handler(args: BriefArgs, ctx: McpToolContext): Promise<unknown> {
+  const { briefData } = await ctx.getQueries();
+  return briefData(args.file, ctx.dbPath, {
+    noTests: args.no_tests,
+  });
+}

package/src/mcp/tools/cfg.ts

@@ -0,0 +1,32 @@
+import { effectiveOffset, MCP_DEFAULTS } from '../middleware.js';
+import type { McpToolContext } from '../types.js';
+
+export const name = 'cfg';
+
+interface CfgArgs {
+  name: string;
+  format?: 'json' | 'dot' | 'mermaid';
+  file?: string;
+  kind?: string;
+  no_tests?: boolean;
+  limit?: number;
+  offset?: number;
+}
+
+export async function handler(args: CfgArgs, ctx: McpToolContext): Promise<unknown> {
+  const { cfgData, cfgToDOT, cfgToMermaid } = await import('../../features/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 ?? 100, 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.ts

@@ -0,0 +1,60 @@
+import { effectiveOffset, MCP_DEFAULTS, MCP_MAX_LIMIT } from '../middleware.js';
+import type { McpToolContext } from '../types.js';
+
+export const name = 'check';
+
+interface CheckArgs {
+  ref?: string;
+  staged?: boolean;
+  rules?: boolean;
+  cycles?: boolean;
+  blast_radius?: number;
+  signatures?: boolean;
+  boundaries?: boolean;
+  depth?: number;
+  file?: string;
+  kind?: string;
+  no_tests?: boolean;
+  limit?: number;
+  offset?: number;
+}
+
+export async function handler(args: CheckArgs, ctx: McpToolContext): Promise<unknown> {
+  const isDiffMode = args.ref || args.staged;
+
+  if (!isDiffMode && !args.rules) {
+    const { manifestoData } = await import('../../features/manifesto.js');
+    return manifestoData(ctx.dbPath, {
+      file: args.file,
+      noTests: args.no_tests,
+      kind: args.kind,
+      limit: Math.min(args.limit ?? MCP_DEFAULTS.manifesto ?? 100, MCP_MAX_LIMIT),
+      offset: effectiveOffset(args),
+    });
+  }
+
+  const { checkData } = await import('../../features/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('../../features/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 ?? 100, MCP_MAX_LIMIT),
+      offset: effectiveOffset(args),
+    });
+    return { check: checkResult, manifesto: manifestoResult };
+  }
+  return checkResult;
+}

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

@@ -0,0 +1,29 @@
+import { effectiveLimit, effectiveOffset } from '../middleware.js';
+import type { McpToolContext } from '../types.js';
+
+export const name = 'co_changes';
+
+interface CoChangesArgs {
+  file?: string;
+  limit?: number;
+  offset?: number;
+  min_jaccard?: number;
+  no_tests?: boolean;
+}
+
+export async function handler(args: CoChangesArgs, ctx: McpToolContext): Promise<unknown> {
+  const { coChangeData, coChangeTopData } = await import('../../features/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.ts

@@ -0,0 +1,22 @@
+import type { McpToolContext } from '../types.js';
+
+export const name = 'code_owners';
+
+interface CodeOwnersArgs {
+  file?: string;
+  owner?: string;
+  boundary?: boolean;
+  kind?: string;
+  no_tests?: boolean;
+}
+
+export async function handler(args: CodeOwnersArgs, ctx: McpToolContext): Promise<unknown> {
+  const { ownersData } = await import('../../features/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.ts

@@ -0,0 +1,25 @@
+import { effectiveLimit, effectiveOffset } from '../middleware.js';
+import type { McpToolContext } from '../types.js';
+
+export const name = 'communities';
+
+interface CommunitiesArgs {
+  functions?: boolean;
+  resolution?: number;
+  drift?: boolean;
+  no_tests?: boolean;
+  limit?: number;
+  offset?: number;
+}
+
+export async function handler(args: CommunitiesArgs, ctx: McpToolContext): Promise<unknown> {
+  const { communitiesData } = await import('../../features/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.ts

@@ -0,0 +1,30 @@
+import { effectiveLimit, effectiveOffset } from '../middleware.js';
+import type { McpToolContext } from '../types.js';
+
+export const name = 'complexity';
+
+interface ComplexityArgs {
+  name?: string;
+  file?: string;
+  limit?: number;
+  offset?: number;
+  sort?: string;
+  above_threshold?: boolean;
+  health?: boolean;
+  no_tests?: boolean;
+  kind?: string;
+}
+
+export async function handler(args: ComplexityArgs, ctx: McpToolContext): Promise<unknown> {
+  const { complexityData } = await import('../../features/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,
+    noTests: args.no_tests,
+    kind: args.kind,
+  });
+}

package/src/mcp/tools/context.ts

@@ -0,0 +1,30 @@
+import { effectiveLimit, effectiveOffset } from '../middleware.js';
+import type { McpToolContext } from '../types.js';
+
+export const name = 'context';
+
+interface ContextArgs {
+  name: string;
+  depth?: number;
+  file?: string;
+  kind?: string;
+  no_source?: boolean;
+  no_tests?: boolean;
+  include_tests?: boolean;
+  limit?: number;
+  offset?: number;
+}
+
+export async function handler(args: ContextArgs, ctx: McpToolContext): Promise<unknown> {
+  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.ts

@@ -0,0 +1,38 @@
+import { effectiveOffset, MCP_DEFAULTS } from '../middleware.js';
+import type { McpToolContext } from '../types.js';
+
+export const name = 'dataflow';
+
+interface DataflowArgs {
+  mode?: string;
+  name: string;
+  depth?: number;
+  file?: string;
+  kind?: string;
+  no_tests?: boolean;
+  limit?: number;
+  offset?: number;
+}
+
+export async function handler(args: DataflowArgs, ctx: McpToolContext): Promise<unknown> {
+  const dfMode = args.mode || 'edges';
+  if (dfMode === 'impact') {
+    const { dataflowImpactData } = await import('../../features/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 ?? 100, ctx.MCP_MAX_LIMIT),
+      offset: effectiveOffset(args),
+    });
+  }
+  const { dataflowData } = await import('../../features/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 ?? 100, ctx.MCP_MAX_LIMIT),
+    offset: effectiveOffset(args),
+  });
+}

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

@@ -0,0 +1,35 @@
+import { effectiveLimit, effectiveOffset } from '../middleware.js';
+import type { McpToolContext } from '../types.js';
+
+export const name = 'diff_impact';
+
+interface DiffImpactArgs {
+  format?: string;
+  staged?: boolean;
+  ref?: string;
+  depth?: number;
+  no_tests?: boolean;
+  limit?: number;
+  offset?: number;
+}
+
+export async function handler(args: DiffImpactArgs, ctx: McpToolContext): Promise<unknown> {
+  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.ts

@@ -0,0 +1,38 @@
+import { effectiveLimit, effectiveOffset } from '../middleware.js';
+import type { McpToolContext } from '../types.js';
+
+export const name = 'execution_flow';
+
+interface ExecutionFlowArgs {
+  list?: boolean;
+  name?: string;
+  depth?: number;
+  file?: string;
+  kind?: string;
+  no_tests?: boolean;
+  limit?: number;
+  offset?: number;
+}
+
+export async function handler(args: ExecutionFlowArgs, ctx: McpToolContext): Promise<unknown> {
+  if (args.list) {
+    const { listEntryPointsData } = await import('../../features/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('../../features/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.ts

@@ -0,0 +1,67 @@
+import { findDbPath } from '../../db/index.js';
+import { effectiveOffset, MCP_DEFAULTS, MCP_MAX_LIMIT } from '../middleware.js';
+import type { McpToolContext } from '../types.js';
+
+export const name = 'export_graph';
+
+interface ExportGraphArgs {
+  format: string;
+  file_level?: boolean;
+  limit?: number;
+  offset?: number;
+}
+
+export async function handler(args: ExportGraphArgs, ctx: McpToolContext): Promise<unknown> {
+  const { exportDOT, exportGraphML, exportGraphSON, exportJSON, exportMermaid, exportNeo4jCSV } =
+    await import('../../features/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 ?? 500);
+
+  let result: unknown;
+  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.ts

@@ -0,0 +1,20 @@
+import { effectiveLimit, effectiveOffset } from '../middleware.js';
+import type { McpToolContext } from '../types.js';
+
+export const name = 'file_deps';
+
+interface FileDepsArgs {
+  file: string;
+  no_tests?: boolean;
+  limit?: number;
+  offset?: number;
+}
+
+export async function handler(args: FileDepsArgs, ctx: McpToolContext): Promise<unknown> {
+  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.ts

@@ -0,0 +1,22 @@
+import { effectiveLimit, effectiveOffset } from '../middleware.js';
+import type { McpToolContext } from '../types.js';
+
+export const name = 'file_exports';
+
+interface FileExportsArgs {
+  file: string;
+  no_tests?: boolean;
+  unused?: boolean;
+  limit?: number;
+  offset?: number;
+}
+
+export async function handler(args: FileExportsArgs, ctx: McpToolContext): Promise<unknown> {
+  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.ts

@@ -0,0 +1,19 @@
+import { findDbPath } from '../../db/index.js';
+import { findCycles } from '../../domain/graph/cycles.js';
+import type { McpToolContext } from '../types.js';
+
+export const name = 'find_cycles';
+
+export async function handler(
+  _args: Record<string, unknown>,
+  ctx: McpToolContext,
+): Promise<{ cycles: string[][]; count: number }> {
+  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.ts

@@ -0,0 +1,26 @@
+import { effectiveLimit, effectiveOffset } from '../middleware.js';
+import type { McpToolContext } from '../types.js';
+
+export const name = 'fn_impact';
+
+interface FnImpactArgs {
+  name: string;
+  depth?: number;
+  file?: string;
+  kind?: string;
+  no_tests?: boolean;
+  limit?: number;
+  offset?: number;
+}
+
+export async function handler(args: FnImpactArgs, ctx: McpToolContext): Promise<unknown> {
+  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.ts

@@ -0,0 +1,15 @@
+import type { McpToolContext } from '../types.js';
+
+export const name = 'impact_analysis';
+
+interface ImpactAnalysisArgs {
+  file: string;
+  no_tests?: boolean;
+}
+
+export async function handler(args: ImpactAnalysisArgs, ctx: McpToolContext): Promise<unknown> {
+  const { impactAnalysisData } = await ctx.getQueries();
+  return impactAnalysisData(args.file, ctx.dbPath, {
+    noTests: args.no_tests,
+  });
+}

package/src/mcp/tools/implementations.ts

@@ -0,0 +1,24 @@
+import { effectiveLimit, effectiveOffset } from '../middleware.js';
+import type { McpToolContext } from '../types.js';
+
+export const name = 'implementations';
+
+interface ImplementationsArgs {
+  name: string;
+  file?: string;
+  kind?: string;
+  no_tests?: boolean;
+  limit?: number;
+  offset?: number;
+}
+
+export async function handler(args: ImplementationsArgs, ctx: McpToolContext): Promise<unknown> {
+  const { implementationsData } = await ctx.getQueries();
+  return implementationsData(args.name, ctx.dbPath, {
+    file: args.file,
+    kind: args.kind,
+    noTests: args.no_tests,
+    limit: effectiveLimit(args, name),
+    offset: effectiveOffset(args),
+  });
+}