@optave/codegraph 3.0.4 → 3.1.1

package/src/mcp.js

@@ -113,6 +113,11 @@ const BASE_TOOLS = [
       properties: {
         file: { type: 'string', description: 'File path (partial match supported)' },
         no_tests: { type: 'boolean', description: 'Exclude test files', default: false },
+        unused: {
+          type: 'boolean',
+          description: 'Show only exports with zero consumers',
+          default: false,
+        },
         ...PAGINATION_PROPS,
       },
       required: ['file'],
@@ -418,6 +423,43 @@ const BASE_TOOLS = [
       },
     },
   },
+  {
+    name: 'sequence',
+    description:
+      'Generate a Mermaid sequence diagram from call graph edges. Participants are files, messages are function calls between them.',
+    inputSchema: {
+      type: 'object',
+      properties: {
+        name: {
+          type: 'string',
+          description: 'Entry point or function name to trace from (partial match)',
+        },
+        depth: { type: 'number', description: 'Max forward traversal depth', default: 10 },
+        format: {
+          type: 'string',
+          enum: ['mermaid', 'json'],
+          description: 'Output format (default: mermaid)',
+        },
+        dataflow: {
+          type: 'boolean',
+          description: 'Annotate with parameter names and return arrows',
+          default: false,
+        },
+        file: {
+          type: 'string',
+          description: 'Scope search to functions in this file (partial match)',
+        },
+        kind: {
+          type: 'string',
+          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: 'complexity',
     description:
@@ -794,26 +836,27 @@ export async function startMCPServer(customDbPath, options = {}) {
     process.exit(1);
   }
 
-  // Lazy import query functions to avoid circular deps at module load
-  const {
-    impactAnalysisData,
-    moduleMapData,
-    fileDepsData,
-    exportsData,
-    fnDepsData,
-    fnImpactData,
-    pathData,
-    contextData,
-    childrenData,
-    explainData,
-    whereData,
-    diffImpactData,
-    listFunctionsData,
-    rolesData,
-  } = await import('./queries.js');
+  // Connect transport FIRST so the server can receive the client's
+  // `initialize` request while heavy modules (queries, better-sqlite3)
+  // are still loading.  These are lazy-loaded on the first tool call
+  // and cached for subsequent calls.
+  let _queries;
+  let _Database;
 
-  const require = createRequire(import.meta.url);
-  const Database = require('better-sqlite3');
+  async function getQueries() {
+    if (!_queries) {
+      _queries = await import('./queries.js');
+    }
+    return _queries;
+  }
+
+  function getDatabase() {
+    if (!_Database) {
+      const require = createRequire(import.meta.url);
+      _Database = require('better-sqlite3');
+    }
+    return _Database;
+  }
 
   const server = new Server(
     { name: 'codegraph', version: '1.0.0' },
@@ -826,8 +869,24 @@ export async function startMCPServer(customDbPath, options = {}) {
 
   server.setRequestHandler(CallToolRequestSchema, async (request) => {
     const { name, arguments: args } = request.params;
-
     try {
+      const {
+        impactAnalysisData,
+        moduleMapData,
+        fileDepsData,
+        exportsData,
+        fnDepsData,
+        fnImpactData,
+        pathData,
+        contextData,
+        childrenData,
+        explainData,
+        whereData,
+        diffImpactData,
+        listFunctionsData,
+        rolesData,
+      } = await getQueries();
+      const Database = getDatabase();
       if (!multiRepo && args.repo) {
         throw new Error(
           'Multi-repo access is disabled. Restart with `codegraph mcp --multi-repo` to access other repositories.',
@@ -902,6 +961,7 @@ export async function startMCPServer(customDbPath, options = {}) {
         case 'file_exports':
           result = exportsData(args.file, dbPath, {
             noTests: args.no_tests,
+            unused: args.unused,
             limit: Math.min(args.limit ?? MCP_DEFAULTS.file_exports, MCP_MAX_LIMIT),
             offset: args.offset ?? 0,
           });
@@ -1165,6 +1225,23 @@ export async function startMCPServer(customDbPath, options = {}) {
           }
           break;
         }
+        case 'sequence': {
+          const { sequenceData, sequenceToMermaid } = await import('./sequence.js');
+          const seqResult = sequenceData(args.name, dbPath, {
+            depth: args.depth,
+            file: args.file,
+            kind: args.kind,
+            dataflow: args.dataflow,
+            noTests: args.no_tests,
+            limit: Math.min(args.limit ?? MCP_DEFAULTS.execution_flow, MCP_MAX_LIMIT),
+            offset: args.offset ?? 0,
+          });
+          result =
+            args.format === 'json'
+              ? seqResult
+              : { text: sequenceToMermaid(seqResult), ...seqResult };
+          break;
+        }
         case 'complexity': {
           const { complexityData } = await import('./complexity.js');
           result = complexityData(dbPath, {

package/src/owners.js

@@ -1,7 +1,8 @@
 import fs from 'node:fs';
 import path from 'node:path';
 import { findDbPath, openReadonlyOrFail } from './db.js';
-import { isTestFile } from './queries.js';
+import { outputResult } from './result-formatter.js';
+import { isTestFile } from './test-filter.js';
 
 // ─── CODEOWNERS Parsing ──────────────────────────────────────────────
 
@@ -163,142 +164,144 @@ export function ownersForFiles(filePaths, repoRoot) {
  */
 export function ownersData(customDbPath, opts = {}) {
   const db = openReadonlyOrFail(customDbPath);
-  const dbPath = findDbPath(customDbPath);
-  const repoRoot = path.resolve(path.dirname(dbPath), '..');
-
-  const parsed = parseCodeowners(repoRoot);
-  if (!parsed) {
-    db.close();
-    return {
-      codeownersFile: null,
-      files: [],
-      symbols: [],
-      boundaries: [],
-      summary: {
-        totalFiles: 0,
-        ownedFiles: 0,
-        unownedFiles: 0,
-        coveragePercent: 0,
-        ownerCount: 0,
-        byOwner: [],
-      },
-    };
-  }
+  try {
+    const dbPath = findDbPath(customDbPath);
+    const repoRoot = path.resolve(path.dirname(dbPath), '..');
+
+    const parsed = parseCodeowners(repoRoot);
+    if (!parsed) {
+      return {
+        codeownersFile: null,
+        files: [],
+        symbols: [],
+        boundaries: [],
+        summary: {
+          totalFiles: 0,
+          ownedFiles: 0,
+          unownedFiles: 0,
+          coveragePercent: 0,
+          ownerCount: 0,
+          byOwner: [],
+        },
+      };
+    }
 
-  // Get all distinct files from nodes
-  let allFiles = db
-    .prepare('SELECT DISTINCT file FROM nodes')
-    .all()
-    .map((r) => r.file);
+    // Get all distinct files from nodes
+    let allFiles = db
+      .prepare('SELECT DISTINCT file FROM nodes')
+      .all()
+      .map((r) => r.file);
 
-  if (opts.noTests) allFiles = allFiles.filter((f) => !isTestFile(f));
-  if (opts.file) {
-    const filter = opts.file;
-    allFiles = allFiles.filter((f) => f.includes(filter));
-  }
+    if (opts.noTests) allFiles = allFiles.filter((f) => !isTestFile(f));
+    if (opts.file) {
+      const filter = opts.file;
+      allFiles = allFiles.filter((f) => f.includes(filter));
+    }
 
-  // Map files to owners
-  const fileOwners = allFiles.map((file) => ({
-    file,
-    owners: matchOwners(file, parsed.rules),
-  }));
-
-  // Build owner-to-files index
-  const ownerIndex = new Map();
-  let ownedCount = 0;
-  for (const fo of fileOwners) {
-    if (fo.owners.length > 0) ownedCount++;
-    for (const o of fo.owners) {
-      if (!ownerIndex.has(o)) ownerIndex.set(o, []);
-      ownerIndex.get(o).push(fo.file);
+    // Map files to owners
+    const fileOwners = allFiles.map((file) => ({
+      file,
+      owners: matchOwners(file, parsed.rules),
+    }));
+
+    // Build owner-to-files index
+    const ownerIndex = new Map();
+    let ownedCount = 0;
+    for (const fo of fileOwners) {
+      if (fo.owners.length > 0) ownedCount++;
+      for (const o of fo.owners) {
+        if (!ownerIndex.has(o)) ownerIndex.set(o, []);
+        ownerIndex.get(o).push(fo.file);
+      }
     }
-  }
 
-  // Filter files if --owner specified
-  let filteredFiles = fileOwners;
-  if (opts.owner) {
-    filteredFiles = fileOwners.filter((fo) => fo.owners.includes(opts.owner));
-  }
+    // Filter files if --owner specified
+    let filteredFiles = fileOwners;
+    if (opts.owner) {
+      filteredFiles = fileOwners.filter((fo) => fo.owners.includes(opts.owner));
+    }
 
-  // Get symbols for filtered files
-  const fileSet = new Set(filteredFiles.map((fo) => fo.file));
-  let symbols = db
-    .prepare('SELECT name, kind, file, line FROM nodes')
-    .all()
-    .filter((n) => fileSet.has(n.file));
-
-  if (opts.noTests) symbols = symbols.filter((s) => !isTestFile(s.file));
-  if (opts.kind) symbols = symbols.filter((s) => s.kind === opts.kind);
-
-  const symbolsWithOwners = symbols.map((s) => ({
-    ...s,
-    owners: matchOwners(s.file, parsed.rules),
-  }));
-
-  // Boundary analysis — cross-owner call edges
-  const boundaries = [];
-  if (opts.boundary) {
-    const edges = db
-      .prepare(
-        `SELECT e.id, e.kind AS edgeKind,
-                s.name AS srcName, s.kind AS srcKind, s.file AS srcFile, s.line AS srcLine,
-                t.name AS tgtName, t.kind AS tgtKind, t.file AS tgtFile, t.line AS tgtLine
-         FROM edges e
-         JOIN nodes s ON e.source_id = s.id
-         JOIN nodes t ON e.target_id = t.id
-         WHERE e.kind = 'calls'`,
-      )
-      .all();
-
-    for (const e of edges) {
-      if (opts.noTests && (isTestFile(e.srcFile) || isTestFile(e.tgtFile))) continue;
-      const srcOwners = matchOwners(e.srcFile, parsed.rules);
-      const tgtOwners = matchOwners(e.tgtFile, parsed.rules);
-      // Cross-boundary: different owner sets
-      const srcKey = srcOwners.sort().join(',');
-      const tgtKey = tgtOwners.sort().join(',');
-      if (srcKey !== tgtKey) {
-        boundaries.push({
-          from: {
-            name: e.srcName,
-            kind: e.srcKind,
-            file: e.srcFile,
-            line: e.srcLine,
-            owners: srcOwners,
-          },
-          to: {
-            name: e.tgtName,
-            kind: e.tgtKind,
-            file: e.tgtFile,
-            line: e.tgtLine,
-            owners: tgtOwners,
-          },
-          edgeKind: e.edgeKind,
-        });
+    // Get symbols for filtered files
+    const fileSet = new Set(filteredFiles.map((fo) => fo.file));
+    let symbols = db
+      .prepare('SELECT name, kind, file, line FROM nodes')
+      .all()
+      .filter((n) => fileSet.has(n.file));
+
+    if (opts.noTests) symbols = symbols.filter((s) => !isTestFile(s.file));
+    if (opts.kind) symbols = symbols.filter((s) => s.kind === opts.kind);
+
+    const symbolsWithOwners = symbols.map((s) => ({
+      ...s,
+      owners: matchOwners(s.file, parsed.rules),
+    }));
+
+    // Boundary analysis — cross-owner call edges
+    const boundaries = [];
+    if (opts.boundary) {
+      const edges = db
+        .prepare(
+          `SELECT e.id, e.kind AS edgeKind,
+                  s.name AS srcName, s.kind AS srcKind, s.file AS srcFile, s.line AS srcLine,
+                  t.name AS tgtName, t.kind AS tgtKind, t.file AS tgtFile, t.line AS tgtLine
+           FROM edges e
+           JOIN nodes s ON e.source_id = s.id
+           JOIN nodes t ON e.target_id = t.id
+           WHERE e.kind = 'calls'`,
+        )
+        .all();
+
+      for (const e of edges) {
+        if (opts.noTests && (isTestFile(e.srcFile) || isTestFile(e.tgtFile))) continue;
+        const srcOwners = matchOwners(e.srcFile, parsed.rules);
+        const tgtOwners = matchOwners(e.tgtFile, parsed.rules);
+        // Cross-boundary: different owner sets
+        const srcKey = srcOwners.sort().join(',');
+        const tgtKey = tgtOwners.sort().join(',');
+        if (srcKey !== tgtKey) {
+          boundaries.push({
+            from: {
+              name: e.srcName,
+              kind: e.srcKind,
+              file: e.srcFile,
+              line: e.srcLine,
+              owners: srcOwners,
+            },
+            to: {
+              name: e.tgtName,
+              kind: e.tgtKind,
+              file: e.tgtFile,
+              line: e.tgtLine,
+              owners: tgtOwners,
+            },
+            edgeKind: e.edgeKind,
+          });
+        }
       }
     }
-  }
 
-  // Summary
-  const byOwner = [...ownerIndex.entries()]
-    .map(([owner, files]) => ({ owner, fileCount: files.length }))
-    .sort((a, b) => b.fileCount - a.fileCount);
-
-  db.close();
-  return {
-    codeownersFile: parsed.path,
-    files: filteredFiles,
-    symbols: symbolsWithOwners,
-    boundaries,
-    summary: {
-      totalFiles: allFiles.length,
-      ownedFiles: ownedCount,
-      unownedFiles: allFiles.length - ownedCount,
-      coveragePercent: allFiles.length > 0 ? Math.round((ownedCount / allFiles.length) * 100) : 0,
-      ownerCount: ownerIndex.size,
-      byOwner,
-    },
-  };
+    // Summary
+    const byOwner = [...ownerIndex.entries()]
+      .map(([owner, files]) => ({ owner, fileCount: files.length }))
+      .sort((a, b) => b.fileCount - a.fileCount);
+
+    return {
+      codeownersFile: parsed.path,
+      files: filteredFiles,
+      symbols: symbolsWithOwners,
+      boundaries,
+      summary: {
+        totalFiles: allFiles.length,
+        ownedFiles: ownedCount,
+        unownedFiles: allFiles.length - ownedCount,
+        coveragePercent: allFiles.length > 0 ? Math.round((ownedCount / allFiles.length) * 100) : 0,
+        ownerCount: ownerIndex.size,
+        byOwner,
+      },
+    };
+  } finally {
+    db.close();
+  }
 }
 
 // ─── CLI Display ─────────────────────────────────────────────────────
@@ -310,10 +313,7 @@ export function ownersData(customDbPath, opts = {}) {
  */
 export function owners(customDbPath, opts = {}) {
   const data = ownersData(customDbPath, opts);
-  if (opts.json) {
-    console.log(JSON.stringify(data, null, 2));
-    return;
-  }
+  if (outputResult(data, null, opts)) return;
 
   if (!data.codeownersFile) {
     console.log('No CODEOWNERS file found.');

package/src/parser.js

@@ -183,133 +183,55 @@ function resolveEngine(opts = {}) {
 }
 
 /**
- * Normalize native engine output to match the camelCase convention
- * used by the WASM extractors.
+ * Patch native engine output in-place for the few remaining semantic transforms.
+ * With #[napi(js_name)] on Rust types, most fields already arrive as camelCase.
+ * This only handles:
+ *  - _lineCount compat for builder.js
+ *  - Backward compat for older native binaries missing js_name annotations
+ *  - dataflow argFlows/mutations bindingType → binding wrapper
  */
-function normalizeNativeSymbols(result) {
-  return {
-    _lineCount: result.lineCount ?? result.line_count ?? null,
-    definitions: (result.definitions || []).map((d) => ({
-      name: d.name,
-      kind: d.kind,
-      line: d.line,
-      endLine: d.endLine ?? d.end_line ?? null,
-      decorators: d.decorators,
-      complexity: d.complexity
-        ? {
-            cognitive: d.complexity.cognitive,
-            cyclomatic: d.complexity.cyclomatic,
-            maxNesting: d.complexity.maxNesting,
-            halstead: d.complexity.halstead ?? null,
-            loc: d.complexity.loc ?? null,
-            maintainabilityIndex: d.complexity.maintainabilityIndex ?? null,
-          }
-        : null,
-      cfg: d.cfg?.blocks?.length
-        ? {
-            blocks: d.cfg.blocks.map((b) => ({
-              index: b.index,
-              type: b.type,
-              startLine: b.startLine,
-              endLine: b.endLine,
-              label: b.label ?? null,
-            })),
-            edges: d.cfg.edges.map((e) => ({
-              sourceIndex: e.sourceIndex,
-              targetIndex: e.targetIndex,
-              kind: e.kind,
-            })),
-          }
-        : null,
-      children: d.children?.length
-        ? d.children.map((c) => ({
-            name: c.name,
-            kind: c.kind,
-            line: c.line,
-            endLine: c.endLine ?? c.end_line ?? null,
-          }))
-        : undefined,
-    })),
-    calls: (result.calls || []).map((c) => ({
-      name: c.name,
-      line: c.line,
-      dynamic: c.dynamic,
-      receiver: c.receiver,
-    })),
-    imports: (result.imports || []).map((i) => ({
-      source: i.source,
-      names: i.names || [],
-      line: i.line,
-      typeOnly: i.typeOnly ?? i.type_only,
-      reexport: i.reexport,
-      wildcardReexport: i.wildcardReexport ?? i.wildcard_reexport,
-      pythonImport: i.pythonImport ?? i.python_import,
-      goImport: i.goImport ?? i.go_import,
-      rustUse: i.rustUse ?? i.rust_use,
-      javaImport: i.javaImport ?? i.java_import,
-      csharpUsing: i.csharpUsing ?? i.csharp_using,
-      rubyRequire: i.rubyRequire ?? i.ruby_require,
-      phpUse: i.phpUse ?? i.php_use,
-    })),
-    classes: (result.classes || []).map((c) => ({
-      name: c.name,
-      extends: c.extends,
-      implements: c.implements,
-      line: c.line,
-    })),
-    exports: (result.exports || []).map((e) => ({
-      name: e.name,
-      kind: e.kind,
-      line: e.line,
-    })),
-    astNodes: (result.astNodes ?? result.ast_nodes ?? []).map((n) => ({
-      kind: n.kind,
-      name: n.name,
-      line: n.line,
-      text: n.text ?? null,
-      receiver: n.receiver ?? null,
-    })),
-    dataflow: result.dataflow
-      ? {
-          parameters: (result.dataflow.parameters || []).map((p) => ({
-            funcName: p.funcName,
-            paramName: p.paramName,
-            paramIndex: p.paramIndex,
-            line: p.line,
-          })),
-          returns: (result.dataflow.returns || []).map((r) => ({
-            funcName: r.funcName,
-            expression: r.expression ?? '',
-            referencedNames: r.referencedNames ?? [],
-            line: r.line,
-          })),
-          assignments: (result.dataflow.assignments || []).map((a) => ({
-            varName: a.varName,
-            callerFunc: a.callerFunc ?? null,
-            sourceCallName: a.sourceCallName,
-            expression: a.expression ?? '',
-            line: a.line,
-          })),
-          argFlows: (result.dataflow.argFlows ?? []).map((f) => ({
-            callerFunc: f.callerFunc ?? null,
-            calleeName: f.calleeName,
-            argIndex: f.argIndex,
-            argName: f.argName ?? null,
-            binding: f.bindingType ? { type: f.bindingType } : null,
-            confidence: f.confidence,
-            expression: f.expression ?? '',
-            line: f.line,
-          })),
-          mutations: (result.dataflow.mutations || []).map((m) => ({
-            funcName: m.funcName ?? null,
-            receiverName: m.receiverName,
-            binding: m.bindingType ? { type: m.bindingType } : null,
-            mutatingExpr: m.mutatingExpr,
-            line: m.line,
-          })),
-        }
-      : null,
-  };
+function patchNativeResult(r) {
+  // lineCount: napi(js_name) emits "lineCount"; older binaries may emit "line_count"
+  r.lineCount = r.lineCount ?? r.line_count ?? null;
+  r._lineCount = r.lineCount;
+
+  // Backward compat for older binaries missing js_name annotations
+  if (r.definitions) {
+    for (const d of r.definitions) {
+      if (d.endLine === undefined && d.end_line !== undefined) {
+        d.endLine = d.end_line;
+      }
+    }
+  }
+  if (r.imports) {
+    for (const i of r.imports) {
+      if (i.typeOnly === undefined) i.typeOnly = i.type_only;
+      if (i.wildcardReexport === undefined) i.wildcardReexport = i.wildcard_reexport;
+      if (i.pythonImport === undefined) i.pythonImport = i.python_import;
+      if (i.goImport === undefined) i.goImport = i.go_import;
+      if (i.rustUse === undefined) i.rustUse = i.rust_use;
+      if (i.javaImport === undefined) i.javaImport = i.java_import;
+      if (i.csharpUsing === undefined) i.csharpUsing = i.csharp_using;
+      if (i.rubyRequire === undefined) i.rubyRequire = i.ruby_require;
+      if (i.phpUse === undefined) i.phpUse = i.php_use;
+    }
+  }
+
+  // dataflow: wrap bindingType into binding object for argFlows and mutations
+  if (r.dataflow) {
+    if (r.dataflow.argFlows) {
+      for (const f of r.dataflow.argFlows) {
+        f.binding = f.bindingType ? { type: f.bindingType } : null;
+      }
+    }
+    if (r.dataflow.mutations) {
+      for (const m of r.dataflow.mutations) {
+        m.binding = m.bindingType ? { type: m.bindingType } : null;
+      }
+    }
+  }
+
+  return r;
 }
 
 /**
@@ -440,8 +362,8 @@ export async function parseFileAuto(filePath, source, opts = {}) {
   const { native } = resolveEngine(opts);
 
   if (native) {
-    const result = native.parseFile(filePath, source, !!opts.dataflow);
-    return result ? normalizeNativeSymbols(result) : null;
+    const result = native.parseFile(filePath, source, !!opts.dataflow, opts.ast !== false);
+    return result ? patchNativeResult(result) : null;
   }
 
   // WASM path
@@ -463,11 +385,16 @@ export async function parseFilesAuto(filePaths, rootDir, opts = {}) {
   const result = new Map();
 
   if (native) {
-    const nativeResults = native.parseFiles(filePaths, rootDir, !!opts.dataflow);
+    const nativeResults = native.parseFiles(
+      filePaths,
+      rootDir,
+      !!opts.dataflow,
+      opts.ast !== false,
+    );
     for (const r of nativeResults) {
       if (!r) continue;
       const relPath = path.relative(rootDir, r.file).split(path.sep).join('/');
-      result.set(relPath, normalizeNativeSymbols(r));
+      result.set(relPath, patchNativeResult(r));
     }
     return result;
   }
@@ -532,7 +459,7 @@ export function createParseTreeCache() {
 export async function parseFileIncremental(cache, filePath, source, opts = {}) {
   if (cache) {
     const result = cache.parseFile(filePath, source);
-    return result ? normalizeNativeSymbols(result) : null;
+    return result ? patchNativeResult(result) : null;
   }
   return parseFileAuto(filePath, source, opts);
 }