@optave/codegraph 3.0.4 → 3.1.0

package/src/cli.js

@@ -277,6 +277,7 @@ program
   .option('--limit <number>', 'Max results to return')
   .option('--offset <number>', 'Skip N results (default: 0)')
   .option('--ndjson', 'Newline-delimited JSON output')
+  .option('--unused', 'Show only exports with zero consumers')
   .action((file, opts) => {
     fileExports(file, opts.db, {
       noTests: resolveNoTests(opts),
@@ -284,6 +285,7 @@ program
       limit: opts.limit ? parseInt(opts.limit, 10) : undefined,
       offset: opts.offset ? parseInt(opts.offset, 10) : undefined,
       ndjson: opts.ndjson,
+      unused: opts.unused,
     });
   });
 
@@ -1137,6 +1139,39 @@ program
     });
   });
 
+program
+  .command('sequence <name>')
+  .description('Generate a Mermaid sequence diagram from call graph edges (participants = files)')
+  .option('--depth <n>', 'Max forward traversal depth', '10')
+  .option('--dataflow', 'Annotate with parameter names and return arrows from dataflow table')
+  .option('-d, --db <path>', 'Path to graph.db')
+  .option('-f, --file <path>', 'Scope to a specific file (partial match)')
+  .option('-k, --kind <kind>', 'Filter by symbol kind')
+  .option('-T, --no-tests', 'Exclude test/spec files from results')
+  .option('--include-tests', 'Include test/spec files (overrides excludeTests config)')
+  .option('-j, --json', 'Output as JSON')
+  .option('--limit <number>', 'Max results to return')
+  .option('--offset <number>', 'Skip N results (default: 0)')
+  .option('--ndjson', 'Newline-delimited JSON output')
+  .action(async (name, opts) => {
+    if (opts.kind && !EVERY_SYMBOL_KIND.includes(opts.kind)) {
+      console.error(`Invalid kind "${opts.kind}". Valid: ${EVERY_SYMBOL_KIND.join(', ')}`);
+      process.exit(1);
+    }
+    const { sequence } = await import('./sequence.js');
+    sequence(name, opts.db, {
+      depth: parseInt(opts.depth, 10),
+      file: opts.file,
+      kind: opts.kind,
+      noTests: resolveNoTests(opts),
+      json: opts.json,
+      dataflow: opts.dataflow,
+      limit: opts.limit ? parseInt(opts.limit, 10) : undefined,
+      offset: opts.offset ? parseInt(opts.offset, 10) : undefined,
+      ndjson: opts.ndjson,
+    });
+  });
+
 program
   .command('dataflow <name>')
   .description('Show data flow for a function: parameters, return consumers, mutations')

package/src/dataflow.js

@@ -1005,9 +1005,17 @@ function collectIdentifiers(node, out, rules) {
 export async function buildDataflowEdges(db, fileSymbols, rootDir, _engineOpts) {
   // Lazily init WASM parsers if needed
   let parsers = null;
-  let extToLang = null;
   let needsFallback = false;
 
+  // Always build ext→langId map so native-only builds (where _langId is unset)
+  // can still derive the language from the file extension.
+  const extToLang = new Map();
+  for (const entry of LANGUAGE_REGISTRY) {
+    for (const ext of entry.extensions) {
+      extToLang.set(ext, entry.id);
+    }
+  }
+
   for (const [relPath, symbols] of fileSymbols) {
     if (!symbols._tree && !symbols.dataflow) {
       const ext = path.extname(relPath).toLowerCase();
@@ -1021,12 +1029,6 @@ export async function buildDataflowEdges(db, fileSymbols, rootDir, _engineOpts)
   if (needsFallback) {
     const { createParsers } = await import('./parser.js');
     parsers = await createParsers();
-    extToLang = new Map();
-    for (const entry of LANGUAGE_REGISTRY) {
-      for (const ext of entry.extensions) {
-        extToLang.set(ext, entry.id);
-      }
-    }
   }
 
   let getParserFn = null;
@@ -1069,7 +1071,7 @@ export async function buildDataflowEdges(db, fileSymbols, rootDir, _engineOpts)
 
         // WASM fallback if no cached tree
         if (!tree) {
-          if (!extToLang || !getParserFn) continue;
+          if (!getParserFn) continue;
           langId = extToLang.get(ext);
           if (!langId || !DATAFLOW_LANG_IDS.has(langId)) continue;
 
@@ -1092,7 +1094,7 @@ export async function buildDataflowEdges(db, fileSymbols, rootDir, _engineOpts)
         }
 
         if (!langId) {
-          langId = extToLang ? extToLang.get(ext) : null;
+          langId = extToLang.get(ext);
           if (!langId) continue;
         }
 

package/src/db.js

@@ -225,6 +225,13 @@ export const MIGRATIONS = [
       CREATE INDEX IF NOT EXISTS idx_ast_kind_name ON ast_nodes(kind, name);
     `,
   },
+  {
+    version: 14,
+    up: `
+      ALTER TABLE nodes ADD COLUMN exported INTEGER DEFAULT 0;
+      CREATE INDEX IF NOT EXISTS idx_nodes_exported ON nodes(exported);
+    `,
+  },
 ];
 
 export function getBuildMeta(db, key) {

package/src/flow.js

@@ -7,7 +7,7 @@
 
 import { openReadonlyOrFail } from './db.js';
 import { paginateResult, printNdjson } from './paginate.js';
-import { isTestFile, kindIcon } from './queries.js';
+import { findMatchingNodes, isTestFile, kindIcon } from './queries.js';
 import { FRAMEWORK_ENTRY_PREFIXES } from './structure.js';
 
 /**
@@ -95,12 +95,12 @@ export function flowData(name, dbPath, opts = {}) {
   const noTests = opts.noTests || false;
 
   // Phase 1: Direct LIKE match on full name
-  let matchNode = findBestMatch(db, name, opts);
+  let matchNode = findMatchingNodes(db, name, opts)[0] ?? null;
 
   // Phase 2: Prefix-stripped matching — try adding framework prefixes
   if (!matchNode) {
     for (const prefix of FRAMEWORK_ENTRY_PREFIXES) {
-      matchNode = findBestMatch(db, `${prefix}${name}`, opts);
+      matchNode = findMatchingNodes(db, `${prefix}${name}`, opts)[0] ?? null;
       if (matchNode) break;
     }
   }
@@ -219,73 +219,6 @@ export function flowData(name, dbPath, opts = {}) {
   return paginateResult(base, 'steps', { limit: opts.limit, offset: opts.offset });
 }
 
-/**
- * Find the best matching node using the same relevance scoring as queries.js findMatchingNodes.
- */
-function findBestMatch(db, name, opts = {}) {
-  const kinds = opts.kind
-    ? [opts.kind]
-    : [
-        'function',
-        'method',
-        'class',
-        'interface',
-        'type',
-        'struct',
-        'enum',
-        'trait',
-        'record',
-        'module',
-      ];
-  const placeholders = kinds.map(() => '?').join(', ');
-  const params = [`%${name}%`, ...kinds];
-
-  let fileCondition = '';
-  if (opts.file) {
-    fileCondition = ' AND n.file LIKE ?';
-    params.push(`%${opts.file}%`);
-  }
-
-  const rows = db
-    .prepare(
-      `SELECT n.*, COALESCE(fi.cnt, 0) AS fan_in
-       FROM nodes n
-       LEFT JOIN (
-         SELECT target_id, COUNT(*) AS cnt FROM edges WHERE kind = 'calls' GROUP BY target_id
-       ) fi ON fi.target_id = n.id
-       WHERE n.name LIKE ? AND n.kind IN (${placeholders})${fileCondition}`,
-    )
-    .all(...params);
-
-  const noTests = opts.noTests || false;
-  const nodes = noTests ? rows.filter((n) => !isTestFile(n.file)) : rows;
-
-  if (nodes.length === 0) return null;
-
-  const lowerQuery = name.toLowerCase();
-  for (const node of nodes) {
-    const lowerName = node.name.toLowerCase();
-    const bareName = lowerName.includes('.') ? lowerName.split('.').pop() : lowerName;
-
-    let matchScore;
-    if (lowerName === lowerQuery || bareName === lowerQuery) {
-      matchScore = 100;
-    } else if (lowerName.startsWith(lowerQuery) || bareName.startsWith(lowerQuery)) {
-      matchScore = 60;
-    } else if (lowerName.includes(`.${lowerQuery}`) || lowerName.includes(`${lowerQuery}.`)) {
-      matchScore = 40;
-    } else {
-      matchScore = 10;
-    }
-
-    const fanInBonus = Math.min(Math.log2(node.fan_in + 1) * 5, 25);
-    node._relevance = matchScore + fanInBonus;
-  }
-
-  nodes.sort((a, b) => b._relevance - a._relevance);
-  return nodes[0];
-}
-
 /**
  * CLI formatter — text or JSON output.
  */

package/src/index.js

@@ -121,7 +121,6 @@ export { isNativeAvailable } from './native.js';
 export { matchOwners, owners, ownersData, ownersForFiles, parseCodeowners } from './owners.js';
 // Pagination utilities
 export { MCP_DEFAULTS, MCP_MAX_LIMIT, paginate, paginateResult, printNdjson } from './paginate.js';
-
 // Unified parser API
 export { getActiveEngine, isWasmAvailable, parseFileAuto, parseFilesAuto } from './parser.js';
 // Query functions (data-returning)
@@ -170,6 +169,8 @@ export {
   saveRegistry,
   unregisterRepo,
 } from './registry.js';
+// Sequence diagram generation
+export { sequence, sequenceData, sequenceToMermaid } from './sequence.js';
 // Snapshot management
 export {
   snapshotDelete,

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:
@@ -902,6 +944,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 +1208,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/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);
 }