@optave/codegraph 3.1.4 → 3.2.0

package/src/extractors/rust.js

@@ -4,191 +4,206 @@ import { findChild, nodeEndLine, rustVisibility } from './helpers.js';
  * Extract symbols from Rust files.
  */
 export function extractRustSymbols(tree, _filePath) {
-  const definitions = [];
-  const calls = [];
-  const imports = [];
-  const classes = [];
-  const exports = [];
+  const ctx = {
+    definitions: [],
+    calls: [],
+    imports: [],
+    classes: [],
+    exports: [],
+  };
 
-  function findCurrentImpl(node) {
-    let current = node.parent;
-    while (current) {
-      if (current.type === 'impl_item') {
-        const typeNode = current.childForFieldName('type');
-        return typeNode ? typeNode.text : null;
-      }
-      current = current.parent;
-    }
-    return null;
+  walkRustNode(tree.rootNode, ctx);
+  return ctx;
+}
+
+function walkRustNode(node, ctx) {
+  switch (node.type) {
+    case 'function_item':
+      handleRustFuncItem(node, ctx);
+      break;
+    case 'struct_item':
+      handleRustStructItem(node, ctx);
+      break;
+    case 'enum_item':
+      handleRustEnumItem(node, ctx);
+      break;
+    case 'const_item':
+      handleRustConstItem(node, ctx);
+      break;
+    case 'trait_item':
+      handleRustTraitItem(node, ctx);
+      break;
+    case 'impl_item':
+      handleRustImplItem(node, ctx);
+      break;
+    case 'use_declaration':
+      handleRustUseDecl(node, ctx);
+      break;
+    case 'call_expression':
+      handleRustCallExpr(node, ctx);
+      break;
+    case 'macro_invocation':
+      handleRustMacroInvocation(node, ctx);
+      break;
   }
 
-  function walkRustNode(node) {
-    switch (node.type) {
-      case 'function_item': {
-        const nameNode = node.childForFieldName('name');
-        if (nameNode) {
-          const implType = findCurrentImpl(node);
-          const fullName = implType ? `${implType}.${nameNode.text}` : nameNode.text;
-          const kind = implType ? 'method' : 'function';
-          const params = extractRustParameters(node.childForFieldName('parameters'));
-          definitions.push({
-            name: fullName,
-            kind,
-            line: node.startPosition.row + 1,
-            endLine: nodeEndLine(node),
-            children: params.length > 0 ? params : undefined,
-            visibility: rustVisibility(node),
-          });
-        }
-        break;
-      }
+  for (let i = 0; i < node.childCount; i++) walkRustNode(node.child(i), ctx);
+}
 
-      case 'struct_item': {
-        const nameNode = node.childForFieldName('name');
-        if (nameNode) {
-          const fields = extractStructFields(node);
-          definitions.push({
-            name: nameNode.text,
-            kind: 'struct',
-            line: node.startPosition.row + 1,
-            endLine: nodeEndLine(node),
-            children: fields.length > 0 ? fields : undefined,
-            visibility: rustVisibility(node),
-          });
-        }
-        break;
-      }
+// ── Walk-path per-node-type handlers ────────────────────────────────────────
 
-      case 'enum_item': {
-        const nameNode = node.childForFieldName('name');
-        if (nameNode) {
-          const variants = extractEnumVariants(node);
-          definitions.push({
-            name: nameNode.text,
-            kind: 'enum',
-            line: node.startPosition.row + 1,
-            endLine: nodeEndLine(node),
-            children: variants.length > 0 ? variants : undefined,
-          });
-        }
-        break;
-      }
+function handleRustFuncItem(node, ctx) {
+  // Skip default-impl functions already emitted by handleRustTraitItem
+  if (node.parent?.parent?.type === 'trait_item') return;
+  const nameNode = node.childForFieldName('name');
+  if (!nameNode) return;
+  const implType = findCurrentImpl(node);
+  const fullName = implType ? `${implType}.${nameNode.text}` : nameNode.text;
+  const kind = implType ? 'method' : 'function';
+  const params = extractRustParameters(node.childForFieldName('parameters'));
+  ctx.definitions.push({
+    name: fullName,
+    kind,
+    line: node.startPosition.row + 1,
+    endLine: nodeEndLine(node),
+    children: params.length > 0 ? params : undefined,
+    visibility: rustVisibility(node),
+  });
+}
 
-      case 'const_item': {
-        const nameNode = node.childForFieldName('name');
-        if (nameNode) {
-          definitions.push({
-            name: nameNode.text,
-            kind: 'constant',
-            line: node.startPosition.row + 1,
-            endLine: nodeEndLine(node),
-          });
-        }
-        break;
-      }
+function handleRustStructItem(node, ctx) {
+  const nameNode = node.childForFieldName('name');
+  if (!nameNode) return;
+  const fields = extractStructFields(node);
+  ctx.definitions.push({
+    name: nameNode.text,
+    kind: 'struct',
+    line: node.startPosition.row + 1,
+    endLine: nodeEndLine(node),
+    children: fields.length > 0 ? fields : undefined,
+    visibility: rustVisibility(node),
+  });
+}
 
-      case 'trait_item': {
-        const nameNode = node.childForFieldName('name');
-        if (nameNode) {
-          definitions.push({
-            name: nameNode.text,
-            kind: 'trait',
-            line: node.startPosition.row + 1,
-            endLine: nodeEndLine(node),
-          });
-          const body = node.childForFieldName('body');
-          if (body) {
-            for (let i = 0; i < body.childCount; i++) {
-              const child = body.child(i);
-              if (
-                child &&
-                (child.type === 'function_signature_item' || child.type === 'function_item')
-              ) {
-                const methName = child.childForFieldName('name');
-                if (methName) {
-                  definitions.push({
-                    name: `${nameNode.text}.${methName.text}`,
-                    kind: 'method',
-                    line: child.startPosition.row + 1,
-                    endLine: child.endPosition.row + 1,
-                  });
-                }
-              }
-            }
-          }
-        }
-        break;
-      }
+function handleRustEnumItem(node, ctx) {
+  const nameNode = node.childForFieldName('name');
+  if (!nameNode) return;
+  const variants = extractEnumVariants(node);
+  ctx.definitions.push({
+    name: nameNode.text,
+    kind: 'enum',
+    line: node.startPosition.row + 1,
+    endLine: nodeEndLine(node),
+    children: variants.length > 0 ? variants : undefined,
+  });
+}
+
+function handleRustConstItem(node, ctx) {
+  const nameNode = node.childForFieldName('name');
+  if (!nameNode) return;
+  ctx.definitions.push({
+    name: nameNode.text,
+    kind: 'constant',
+    line: node.startPosition.row + 1,
+    endLine: nodeEndLine(node),
+  });
+}
 
-      case 'impl_item': {
-        const typeNode = node.childForFieldName('type');
-        const traitNode = node.childForFieldName('trait');
-        if (typeNode && traitNode) {
-          classes.push({
-            name: typeNode.text,
-            implements: traitNode.text,
-            line: node.startPosition.row + 1,
+function handleRustTraitItem(node, ctx) {
+  const nameNode = node.childForFieldName('name');
+  if (!nameNode) return;
+  ctx.definitions.push({
+    name: nameNode.text,
+    kind: 'trait',
+    line: node.startPosition.row + 1,
+    endLine: nodeEndLine(node),
+  });
+  const body = node.childForFieldName('body');
+  if (body) {
+    for (let i = 0; i < body.childCount; i++) {
+      const child = body.child(i);
+      if (child && (child.type === 'function_signature_item' || child.type === 'function_item')) {
+        const methName = child.childForFieldName('name');
+        if (methName) {
+          ctx.definitions.push({
+            name: `${nameNode.text}.${methName.text}`,
+            kind: 'method',
+            line: child.startPosition.row + 1,
+            endLine: child.endPosition.row + 1,
           });
         }
-        break;
       }
+    }
+  }
+}
 
-      case 'use_declaration': {
-        const argNode = node.child(1);
-        if (argNode) {
-          const usePaths = extractRustUsePath(argNode);
-          for (const imp of usePaths) {
-            imports.push({
-              source: imp.source,
-              names: imp.names,
-              line: node.startPosition.row + 1,
-              rustUse: true,
-            });
-          }
-        }
-        break;
-      }
+function handleRustImplItem(node, ctx) {
+  const typeNode = node.childForFieldName('type');
+  const traitNode = node.childForFieldName('trait');
+  if (typeNode && traitNode) {
+    ctx.classes.push({
+      name: typeNode.text,
+      implements: traitNode.text,
+      line: node.startPosition.row + 1,
+    });
+  }
+}
 
-      case 'call_expression': {
-        const fn = node.childForFieldName('function');
-        if (fn) {
-          if (fn.type === 'identifier') {
-            calls.push({ name: fn.text, line: node.startPosition.row + 1 });
-          } else if (fn.type === 'field_expression') {
-            const field = fn.childForFieldName('field');
-            if (field) {
-              const value = fn.childForFieldName('value');
-              const call = { name: field.text, line: node.startPosition.row + 1 };
-              if (value) call.receiver = value.text;
-              calls.push(call);
-            }
-          } else if (fn.type === 'scoped_identifier') {
-            const name = fn.childForFieldName('name');
-            if (name) {
-              const path = fn.childForFieldName('path');
-              const call = { name: name.text, line: node.startPosition.row + 1 };
-              if (path) call.receiver = path.text;
-              calls.push(call);
-            }
-          }
-        }
-        break;
-      }
+function handleRustUseDecl(node, ctx) {
+  const argNode = node.child(1);
+  if (!argNode) return;
+  const usePaths = extractRustUsePath(argNode);
+  for (const imp of usePaths) {
+    ctx.imports.push({
+      source: imp.source,
+      names: imp.names,
+      line: node.startPosition.row + 1,
+      rustUse: true,
+    });
+  }
+}
 
-      case 'macro_invocation': {
-        const macroNode = node.child(0);
-        if (macroNode) {
-          calls.push({ name: `${macroNode.text}!`, line: node.startPosition.row + 1 });
-        }
-        break;
-      }
+function handleRustCallExpr(node, ctx) {
+  const fn = node.childForFieldName('function');
+  if (!fn) return;
+  if (fn.type === 'identifier') {
+    ctx.calls.push({ name: fn.text, line: node.startPosition.row + 1 });
+  } else if (fn.type === 'field_expression') {
+    const field = fn.childForFieldName('field');
+    if (field) {
+      const value = fn.childForFieldName('value');
+      const call = { name: field.text, line: node.startPosition.row + 1 };
+      if (value) call.receiver = value.text;
+      ctx.calls.push(call);
+    }
+  } else if (fn.type === 'scoped_identifier') {
+    const name = fn.childForFieldName('name');
+    if (name) {
+      const path = fn.childForFieldName('path');
+      const call = { name: name.text, line: node.startPosition.row + 1 };
+      if (path) call.receiver = path.text;
+      ctx.calls.push(call);
     }
+  }
+}
 
-    for (let i = 0; i < node.childCount; i++) walkRustNode(node.child(i));
+function handleRustMacroInvocation(node, ctx) {
+  const macroNode = node.child(0);
+  if (macroNode) {
+    ctx.calls.push({ name: `${macroNode.text}!`, line: node.startPosition.row + 1 });
   }
+}
 
-  walkRustNode(tree.rootNode);
-  return { definitions, calls, imports, classes, exports };
+function findCurrentImpl(node) {
+  let current = node.parent;
+  while (current) {
+    if (current.type === 'impl_item') {
+      const typeNode = current.childForFieldName('type');
+      return typeNode ? typeNode.text : null;
+    }
+    current = current.parent;
+  }
+  return null;
 }
 
 // ── Child extraction helpers ────────────────────────────────────────────────

package/src/{ast.js → features/ast.js}

@@ -7,14 +7,15 @@
  */
 
 import path from 'node:path';
-import { AST_TYPE_MAPS } from './ast-analysis/rules/index.js';
-import { buildExtensionSet } from './ast-analysis/shared.js';
-import { walkWithVisitors } from './ast-analysis/visitor.js';
-import { createAstStoreVisitor } from './ast-analysis/visitors/ast-store-visitor.js';
-import { bulkNodeIdsByFile, openReadonlyOrFail } from './db.js';
-import { outputResult } from './infrastructure/result-formatter.js';
-import { debug } from './logger.js';
-import { paginateResult } from './paginate.js';
+import { AST_TYPE_MAPS } from '../ast-analysis/rules/index.js';
+import { buildExtensionSet } from '../ast-analysis/shared.js';
+import { walkWithVisitors } from '../ast-analysis/visitor.js';
+import { createAstStoreVisitor } from '../ast-analysis/visitors/ast-store-visitor.js';
+import { bulkNodeIdsByFile, openReadonlyOrFail } from '../db/index.js';
+import { buildFileConditionSQL } from '../db/query-builder.js';
+import { debug } from '../infrastructure/logger.js';
+import { outputResult } from '../infrastructure/result-formatter.js';
+import { paginateResult } from '../shared/paginate.js';
 
 // ─── Constants ────────────────────────────────────────────────────────
 
@@ -193,9 +194,10 @@ export function astQueryData(pattern, customDbPath, opts = {}) {
     params.push(kind);
   }
 
-  if (file) {
-    where += ' AND a.file LIKE ?';
-    params.push(`%${file}%`);
+  {
+    const fc = buildFileConditionSQL(file, 'a.file');
+    where += fc.sql;
+    params.push(...fc.params);
   }
 
   if (noTests) {

package/src/{audit.js → features/audit.js}

@@ -7,21 +7,27 @@
  */
 
 import path from 'node:path';
-import { loadConfig } from './config.js';
-import { openReadonlyOrFail } from './db.js';
-import { isTestFile } from './infrastructure/test-filter.js';
+import { openReadonlyOrFail } from '../db/index.js';
+import { normalizeFileFilter } from '../db/query-builder.js';
+import { bfsTransitiveCallers } from '../domain/analysis/impact.js';
+import { explainData } from '../domain/queries.js';
+import { loadConfig } from '../infrastructure/config.js';
+import { isTestFile } from '../infrastructure/test-filter.js';
 import { RULE_DEFS } from './manifesto.js';
-import { explainData } from './queries.js';
 
 // ─── Threshold resolution ───────────────────────────────────────────
 
 const FUNCTION_RULES = RULE_DEFS.filter((d) => d.level === 'function');
 
-function resolveThresholds(customDbPath) {
+function resolveThresholds(customDbPath, config) {
   try {
-    const dbDir = path.dirname(customDbPath);
-    const repoRoot = path.resolve(dbDir, '..');
-    const cfg = loadConfig(repoRoot);
+    const cfg =
+      config ||
+      (() => {
+        const dbDir = path.dirname(customDbPath);
+        const repoRoot = path.resolve(dbDir, '..');
+        return loadConfig(repoRoot);
+      })();
     const userRules = cfg.manifesto || {};
     const resolved = {};
     for (const def of FUNCTION_RULES) {
@@ -70,39 +76,6 @@ function checkBreaches(row, thresholds) {
   return breaches;
 }
 
-// ─── BFS impact (inline, same algorithm as fnImpactData) ────────────
-
-function computeImpact(db, nodeId, noTests, maxDepth) {
-  const visited = new Set([nodeId]);
-  const levels = {};
-  let frontier = [nodeId];
-
-  for (let d = 1; d <= maxDepth; d++) {
-    const nextFrontier = [];
-    for (const fid of frontier) {
-      const callers = db
-        .prepare(
-          `SELECT DISTINCT n.id, n.name, n.kind, n.file, n.line
-           FROM edges e JOIN nodes n ON e.source_id = n.id
-           WHERE e.target_id = ? AND e.kind = 'calls'`,
-        )
-        .all(fid);
-      for (const c of callers) {
-        if (!visited.has(c.id) && (!noTests || !isTestFile(c.file))) {
-          visited.add(c.id);
-          nextFrontier.push(c.id);
-          if (!levels[d]) levels[d] = [];
-          levels[d].push({ name: c.name, kind: c.kind, file: c.file, line: c.line });
-        }
-      }
-    }
-    frontier = nextFrontier;
-    if (frontier.length === 0) break;
-  }
-
-  return { totalDependents: visited.size - 1, levels };
-}
-
 // ─── Phase 4.4 fields (graceful null fallback) ─────────────────────
 
 function readPhase44(db, nodeId) {
@@ -128,7 +101,7 @@ function readPhase44(db, nodeId) {
 export function auditData(target, customDbPath, opts = {}) {
   const noTests = opts.noTests || false;
   const maxDepth = opts.depth || 3;
-  const file = opts.file;
+  const fileFilters = normalizeFileFilter(opts.file);
   const kind = opts.kind;
 
   // 1. Get structure via explainData
@@ -137,7 +110,8 @@ export function auditData(target, customDbPath, opts = {}) {
   // Apply --file and --kind filters for function targets
   let results = explained.results;
   if (explained.kind === 'function') {
-    if (file) results = results.filter((r) => r.file.includes(file));
+    if (fileFilters.length > 0)
+      results = results.filter((r) => fileFilters.some((f) => r.file.includes(f)));
     if (kind) results = results.filter((r) => r.kind === kind);
   }
 
@@ -147,7 +121,7 @@ export function auditData(target, customDbPath, opts = {}) {
 
   // 2. Open DB for enrichment
   const db = openReadonlyOrFail(customDbPath);
-  const thresholds = resolveThresholds(customDbPath);
+  const thresholds = resolveThresholds(customDbPath, opts.config);
 
   let functions;
   try {
@@ -189,7 +163,7 @@ function enrichFunction(db, r, noTests, maxDepth, thresholds) {
   const nodeId = nodeRow?.id;
   const health = nodeId ? buildHealth(db, nodeId, thresholds) : defaultHealth();
   const impact = nodeId
-    ? computeImpact(db, nodeId, noTests, maxDepth)
+    ? bfsTransitiveCallers(db, nodeId, { noTests, maxDepth })
     : { totalDependents: 0, levels: {} };
   const phase44 = nodeId
     ? readPhase44(db, nodeId)
@@ -260,7 +234,7 @@ function enrichSymbol(db, sym, file, noTests, maxDepth, thresholds) {
 
   const health = nodeId ? buildHealth(db, nodeId, thresholds) : defaultHealth();
   const impact = nodeId
-    ? computeImpact(db, nodeId, noTests, maxDepth)
+    ? bfsTransitiveCallers(db, nodeId, { noTests, maxDepth })
     : { totalDependents: 0, levels: {} };
   const phase44 = nodeId
     ? readPhase44(db, nodeId)

package/src/{batch.js → features/batch.js}

@@ -5,10 +5,6 @@
  * Designed for multi-agent swarms that need to dispatch 20+ queries in one call.
  */
 
-import { complexityData } from './complexity.js';
-import { dataflowData } from './dataflow.js';
-import { ConfigError } from './errors.js';
-import { flowData } from './flow.js';
 import {
   contextData,
   explainData,
@@ -18,7 +14,11 @@ import {
   fnImpactData,
   impactAnalysisData,
   whereData,
-} from './queries.js';
+} from '../domain/queries.js';
+import { ConfigError } from '../shared/errors.js';
+import { complexityData } from './complexity.js';
+import { dataflowData } from './dataflow.js';
+import { flowData } from './flow.js';
 
 /**
  * Map of supported batch commands → their data function + first-arg semantics.