@optave/codegraph 3.0.4 → 3.1.1

package/src/flow.js

@@ -6,9 +6,11 @@
  */
 
 import { openReadonlyOrFail } from './db.js';
-import { paginateResult, printNdjson } from './paginate.js';
-import { isTestFile, kindIcon } from './queries.js';
+import { paginateResult } from './paginate.js';
+import { CORE_SYMBOL_KINDS, findMatchingNodes, kindIcon } from './queries.js';
+import { outputResult } from './result-formatter.js';
 import { FRAMEWORK_ENTRY_PREFIXES } from './structure.js';
+import { isTestFile } from './test-filter.js';
 
 /**
  * Determine the entry point type from a node name based on framework prefixes.
@@ -35,46 +37,49 @@ export function entryPointType(name) {
  */
 export function listEntryPointsData(dbPath, opts = {}) {
   const db = openReadonlyOrFail(dbPath);
-  const noTests = opts.noTests || false;
-
-  // Find all framework-prefixed nodes
-  const prefixConditions = FRAMEWORK_ENTRY_PREFIXES.map(() => 'n.name LIKE ?').join(' OR ');
-  const prefixParams = FRAMEWORK_ENTRY_PREFIXES.map((p) => `${p}%`);
-
-  let rows = db
-    .prepare(
-      `SELECT n.name, n.kind, n.file, n.line, n.role
-       FROM nodes n
-       WHERE (
-         (${prefixConditions})
-         OR n.role = 'entry'
-       )
-         AND n.kind NOT IN ('file', 'directory')
-       ORDER BY n.name`,
-    )
-    .all(...prefixParams);
-
-  if (noTests) rows = rows.filter((r) => !isTestFile(r.file));
-
-  const entries = rows.map((r) => ({
-    name: r.name,
-    kind: r.kind,
-    file: r.file,
-    line: r.line,
-    role: r.role,
-    type: entryPointType(r.name) || (r.role === 'entry' ? 'exported' : null),
-  }));
-
-  const byType = {};
-  for (const e of entries) {
-    const t = e.type || 'other';
-    if (!byType[t]) byType[t] = [];
-    byType[t].push(e);
-  }
+  try {
+    const noTests = opts.noTests || false;
+
+    // Find all framework-prefixed nodes
+    const prefixConditions = FRAMEWORK_ENTRY_PREFIXES.map(() => 'n.name LIKE ?').join(' OR ');
+    const prefixParams = FRAMEWORK_ENTRY_PREFIXES.map((p) => `${p}%`);
 
-  db.close();
-  const base = { entries, byType, count: entries.length };
-  return paginateResult(base, 'entries', { limit: opts.limit, offset: opts.offset });
+    let rows = db
+      .prepare(
+        `SELECT n.name, n.kind, n.file, n.line, n.role
+         FROM nodes n
+         WHERE (
+           (${prefixConditions})
+           OR n.role = 'entry'
+         )
+           AND n.kind NOT IN ('file', 'directory')
+         ORDER BY n.name`,
+      )
+      .all(...prefixParams);
+
+    if (noTests) rows = rows.filter((r) => !isTestFile(r.file));
+
+    const entries = rows.map((r) => ({
+      name: r.name,
+      kind: r.kind,
+      file: r.file,
+      line: r.line,
+      role: r.role,
+      type: entryPointType(r.name) || (r.role === 'entry' ? 'exported' : null),
+    }));
+
+    const byType = {};
+    for (const e of entries) {
+      const t = e.type || 'other';
+      if (!byType[t]) byType[t] = [];
+      byType[t].push(e);
+    }
+
+    const base = { entries, byType, count: entries.length };
+    return paginateResult(base, 'entries', { limit: opts.limit, offset: opts.offset });
+  } finally {
+    db.close();
+  }
 }
 
 /**
@@ -91,199 +96,136 @@ export function listEntryPointsData(dbPath, opts = {}) {
  */
 export function flowData(name, dbPath, opts = {}) {
   const db = openReadonlyOrFail(dbPath);
-  const maxDepth = opts.depth || 10;
-  const noTests = opts.noTests || false;
-
-  // Phase 1: Direct LIKE match on full name
-  let matchNode = findBestMatch(db, name, opts);
+  try {
+    const maxDepth = opts.depth || 10;
+    const noTests = opts.noTests || false;
+    const flowOpts = { ...opts, kinds: opts.kind ? [opts.kind] : CORE_SYMBOL_KINDS };
+
+    // Phase 1: Direct LIKE match on full name (use all 10 core symbol kinds,
+    // not just FUNCTION_KINDS, so flow can trace from interfaces/types/structs/etc.)
+    let matchNode = findMatchingNodes(db, name, flowOpts)[0] ?? null;
+
+    // Phase 2: Prefix-stripped matching — try adding framework prefixes
+    if (!matchNode) {
+      for (const prefix of FRAMEWORK_ENTRY_PREFIXES) {
+        matchNode = findMatchingNodes(db, `${prefix}${name}`, flowOpts)[0] ?? null;
+        if (matchNode) break;
+      }
+    }
 
-  // Phase 2: Prefix-stripped matching — try adding framework prefixes
-  if (!matchNode) {
-    for (const prefix of FRAMEWORK_ENTRY_PREFIXES) {
-      matchNode = findBestMatch(db, `${prefix}${name}`, opts);
-      if (matchNode) break;
+    if (!matchNode) {
+      return {
+        entry: null,
+        depth: maxDepth,
+        steps: [],
+        leaves: [],
+        cycles: [],
+        totalReached: 0,
+        truncated: false,
+      };
     }
-  }
 
-  if (!matchNode) {
-    db.close();
-    return {
-      entry: null,
-      depth: maxDepth,
-      steps: [],
-      leaves: [],
-      cycles: [],
-      totalReached: 0,
-      truncated: false,
+    const epType = entryPointType(matchNode.name);
+    const entry = {
+      name: matchNode.name,
+      kind: matchNode.kind,
+      file: matchNode.file,
+      line: matchNode.line,
+      type: epType || 'exported',
+      role: matchNode.role,
     };
-  }
-
-  const epType = entryPointType(matchNode.name);
-  const entry = {
-    name: matchNode.name,
-    kind: matchNode.kind,
-    file: matchNode.file,
-    line: matchNode.line,
-    type: epType || 'exported',
-    role: matchNode.role,
-  };
-
-  // Forward BFS through callees
-  const visited = new Set([matchNode.id]);
-  let frontier = [matchNode.id];
-  const steps = [];
-  const cycles = [];
-  let truncated = false;
-
-  // Track which nodes are at each depth and their depth for leaf detection
-  const nodeDepths = new Map();
-  const idToNode = new Map();
-  idToNode.set(matchNode.id, entry);
-
-  for (let d = 1; d <= maxDepth; d++) {
-    const nextFrontier = [];
-    const levelNodes = [];
-
-    for (const fid of frontier) {
-      const callees = db
-        .prepare(
-          `SELECT DISTINCT n.id, n.name, n.kind, n.file, n.line, n.role
-           FROM edges e JOIN nodes n ON e.target_id = n.id
-           WHERE e.source_id = ? AND e.kind = 'calls'`,
-        )
-        .all(fid);
-
-      for (const c of callees) {
-        if (noTests && isTestFile(c.file)) continue;
 
-        if (visited.has(c.id)) {
-          // Cycle detected
-          const fromNode = idToNode.get(fid);
-          if (fromNode) {
-            cycles.push({ from: fromNode.name, to: c.name, depth: d });
+    // Forward BFS through callees
+    const visited = new Set([matchNode.id]);
+    let frontier = [matchNode.id];
+    const steps = [];
+    const cycles = [];
+    let truncated = false;
+
+    // Track which nodes are at each depth and their depth for leaf detection
+    const nodeDepths = new Map();
+    const idToNode = new Map();
+    idToNode.set(matchNode.id, entry);
+
+    for (let d = 1; d <= maxDepth; d++) {
+      const nextFrontier = [];
+      const levelNodes = [];
+
+      for (const fid of frontier) {
+        const callees = db
+          .prepare(
+            `SELECT DISTINCT n.id, n.name, n.kind, n.file, n.line, n.role
+             FROM edges e JOIN nodes n ON e.target_id = n.id
+             WHERE e.source_id = ? AND e.kind = 'calls'`,
+          )
+          .all(fid);
+
+        for (const c of callees) {
+          if (noTests && isTestFile(c.file)) continue;
+
+          if (visited.has(c.id)) {
+            // Cycle detected
+            const fromNode = idToNode.get(fid);
+            if (fromNode) {
+              cycles.push({ from: fromNode.name, to: c.name, depth: d });
+            }
+            continue;
           }
-          continue;
-        }
 
-        visited.add(c.id);
-        nextFrontier.push(c.id);
-        const nodeInfo = { name: c.name, kind: c.kind, file: c.file, line: c.line };
-        levelNodes.push(nodeInfo);
-        nodeDepths.set(c.id, d);
-        idToNode.set(c.id, nodeInfo);
+          visited.add(c.id);
+          nextFrontier.push(c.id);
+          const nodeInfo = { name: c.name, kind: c.kind, file: c.file, line: c.line };
+          levelNodes.push(nodeInfo);
+          nodeDepths.set(c.id, d);
+          idToNode.set(c.id, nodeInfo);
+        }
       }
-    }
-
-    if (levelNodes.length > 0) {
-      steps.push({ depth: d, nodes: levelNodes });
-    }
-
-    frontier = nextFrontier;
-    if (frontier.length === 0) break;
 
-    if (d === maxDepth && frontier.length > 0) {
-      truncated = true;
-    }
-  }
+      if (levelNodes.length > 0) {
+        steps.push({ depth: d, nodes: levelNodes });
+      }
 
-  // Identify leaves: visited nodes that have no outgoing 'calls' edges to other visited nodes
-  // (or no outgoing calls at all)
-  const leaves = [];
-  for (const [id, depth] of nodeDepths) {
-    const outgoing = db
-      .prepare(
-        `SELECT DISTINCT n.id
-         FROM edges e JOIN nodes n ON e.target_id = n.id
-         WHERE e.source_id = ? AND e.kind = 'calls'`,
-      )
-      .all(id);
+      frontier = nextFrontier;
+      if (frontier.length === 0) break;
 
-    if (outgoing.length === 0) {
-      const node = idToNode.get(id);
-      if (node) {
-        leaves.push({ ...node, depth });
+      if (d === maxDepth && frontier.length > 0) {
+        truncated = true;
       }
     }
-  }
-
-  db.close();
-  const base = {
-    entry,
-    depth: maxDepth,
-    steps,
-    leaves,
-    cycles,
-    totalReached: visited.size - 1, // exclude the entry node itself
-    truncated,
-  };
-  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}%`);
-  }
+    // Identify leaves: visited nodes that have no outgoing 'calls' edges to other visited nodes
+    // (or no outgoing calls at all)
+    const leaves = [];
+    for (const [id, depth] of nodeDepths) {
+      const outgoing = db
+        .prepare(
+          `SELECT DISTINCT n.id
+           FROM edges e JOIN nodes n ON e.target_id = n.id
+           WHERE e.source_id = ? AND e.kind = 'calls'`,
+        )
+        .all(id);
 
-  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;
+      if (outgoing.length === 0) {
+        const node = idToNode.get(id);
+        if (node) {
+          leaves.push({ ...node, depth });
+        }
+      }
     }
 
-    const fanInBonus = Math.min(Math.log2(node.fan_in + 1) * 5, 25);
-    node._relevance = matchScore + fanInBonus;
+    const base = {
+      entry,
+      depth: maxDepth,
+      steps,
+      leaves,
+      cycles,
+      totalReached: visited.size - 1, // exclude the entry node itself
+      truncated,
+    };
+    return paginateResult(base, 'steps', { limit: opts.limit, offset: opts.offset });
+  } finally {
+    db.close();
   }
-
-  nodes.sort((a, b) => b._relevance - a._relevance);
-  return nodes[0];
 }
 
 /**
@@ -296,14 +238,7 @@ export function flow(name, dbPath, opts = {}) {
       limit: opts.limit,
       offset: opts.offset,
     });
-    if (opts.ndjson) {
-      printNdjson(data, 'entries');
-      return;
-    }
-    if (opts.json) {
-      console.log(JSON.stringify(data, null, 2));
-      return;
-    }
+    if (outputResult(data, 'entries', opts)) return;
     if (data.count === 0) {
       console.log('No entry points found. Run "codegraph build" first.');
       return;
@@ -320,10 +255,7 @@ export function flow(name, dbPath, opts = {}) {
   }
 
   const data = flowData(name, dbPath, opts);
-  if (opts.json) {
-    console.log(JSON.stringify(data, null, 2));
-    return;
-  }
+  if (outputResult(data, 'steps', opts)) return;
 
   if (!data.entry) {
     console.log(`No matching entry point or function found for "${name}".`);

package/src/index.js

@@ -77,12 +77,24 @@ export {
 } from './dataflow.js';
 // Database utilities
 export {
+  countEdges,
+  countFiles,
+  countNodes,
+  fanInJoinSQL,
+  fanOutJoinSQL,
   findDbPath,
+  findNodesForTriage,
+  findNodesWithFanIn,
   getBuildMeta,
   initSchema,
+  iterateFunctionNodes,
+  kindInClause,
+  listFunctionNodes,
+  NodeQuery,
   openDb,
   openReadonlyOrFail,
   setBuildMeta,
+  testFilterSQL,
 } from './db.js';
 // Embeddings
 export {
@@ -121,7 +133,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)
@@ -141,7 +152,6 @@ export {
   FALSE_POSITIVE_CALLER_THRESHOLD,
   FALSE_POSITIVE_NAMES,
   fileDepsData,
-  fileExports,
   fnDepsData,
   fnImpactData,
   impactAnalysisData,
@@ -159,6 +169,24 @@ export {
   VALID_ROLES,
   whereData,
 } from './queries.js';
+// Query CLI display wrappers
+export {
+  children,
+  context,
+  diffImpact,
+  explain,
+  fileDeps,
+  fileExports,
+  fnDeps,
+  fnImpact,
+  impactAnalysis,
+  moduleMap,
+  queryName,
+  roles,
+  stats,
+  symbolPath,
+  where,
+} from './queries-cli.js';
 // Registry (multi-repo)
 export {
   listRepos,
@@ -170,6 +198,10 @@ export {
   saveRegistry,
   unregisterRepo,
 } from './registry.js';
+// Result formatting
+export { outputResult } from './result-formatter.js';
+// Sequence diagram generation
+export { sequence, sequenceData, sequenceToMermaid } from './sequence.js';
 // Snapshot management
 export {
   snapshotDelete,
@@ -191,6 +223,8 @@ export {
   moduleBoundariesData,
   structureData,
 } from './structure.js';
+// Test file detection
+export { isTestFile, TEST_PATTERN } from './test-filter.js';
 // Triage — composite risk audit
 export { triage, triageData } from './triage.js';
 // Interactive HTML viewer

package/src/kinds.js

@@ -0,0 +1,49 @@
+// ── Symbol kind constants ───────────────────────────────────────────
+// Original 10 kinds — used as default query scope
+export const CORE_SYMBOL_KINDS = [
+  'function',
+  'method',
+  'class',
+  'interface',
+  'type',
+  'struct',
+  'enum',
+  'trait',
+  'record',
+  'module',
+];
+
+// Sub-declaration kinds (Phase 1)
+export const EXTENDED_SYMBOL_KINDS = [
+  'parameter',
+  'property',
+  'constant',
+  // Phase 2 (reserved, not yet extracted):
+  // 'constructor', 'namespace', 'decorator', 'getter', 'setter',
+];
+
+// Full set for --kind validation and MCP enum
+export const EVERY_SYMBOL_KIND = [...CORE_SYMBOL_KINDS, ...EXTENDED_SYMBOL_KINDS];
+
+// Backward compat: ALL_SYMBOL_KINDS stays as the core 10
+export const ALL_SYMBOL_KINDS = CORE_SYMBOL_KINDS;
+
+// ── Edge kind constants ─────────────────────────────────────────────
+// Core edge kinds — coupling and dependency relationships
+export const CORE_EDGE_KINDS = [
+  'imports',
+  'imports-type',
+  'reexports',
+  'calls',
+  'extends',
+  'implements',
+  'contains',
+];
+
+// Structural edge kinds — parent/child and type relationships
+export const STRUCTURAL_EDGE_KINDS = ['parameter_of', 'receiver'];
+
+// Full set for MCP enum and validation
+export const EVERY_EDGE_KIND = [...CORE_EDGE_KINDS, ...STRUCTURAL_EDGE_KINDS];
+
+export const VALID_ROLES = ['entry', 'core', 'utility', 'adapter', 'dead', 'leaf'];

package/src/manifesto.js

@@ -3,7 +3,8 @@ import { loadConfig } from './config.js';
 import { findCycles } from './cycles.js';
 import { openReadonlyOrFail } from './db.js';
 import { debug } from './logger.js';
-import { paginateResult, printNdjson } from './paginate.js';
+import { paginateResult } from './paginate.js';
+import { outputResult } from './result-formatter.js';
 
 // ─── Rule Definitions ─────────────────────────────────────────────────
 
@@ -434,13 +435,7 @@ export function manifestoData(customDbPath, opts = {}) {
 export function manifesto(customDbPath, opts = {}) {
   const data = manifestoData(customDbPath, opts);
 
-  if (opts.ndjson) {
-    printNdjson(data, 'violations');
-    if (!data.passed) process.exit(1);
-    return;
-  }
-  if (opts.json) {
-    console.log(JSON.stringify(data, null, 2));
+  if (outputResult(data, 'violations', opts)) {
     if (!data.passed) process.exit(1);
     return;
   }