@optave/codegraph 3.1.5 → 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/features/ast.js

@@ -12,6 +12,7 @@ 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';
@@ -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/features/audit.js

@@ -8,6 +8,7 @@
 
 import path from 'node:path';
 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';
@@ -100,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
@@ -109,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);
   }
 

package/src/features/boundaries.js

@@ -94,104 +94,119 @@ export function resolveModules(boundaryConfig) {
 // ─── Validation ──────────────────────────────────────────────────────
 
 /**
- * Validate a boundary configuration object.
- * @param {object} config - The `manifesto.boundaries` config
- * @returns {{ valid: boolean, errors: string[] }}
+ * Validate the `modules` section of a boundary config.
+ * @param {object} modules
+ * @param {string[]} errors - Mutated: push any validation errors
  */
-export function validateBoundaryConfig(config) {
-  const errors = [];
+function validateModules(modules, errors) {
+  if (!modules || typeof modules !== 'object' || Object.keys(modules).length === 0) {
+    errors.push('boundaries.modules must be a non-empty object');
+    return;
+  }
+  for (const [name, value] of Object.entries(modules)) {
+    if (typeof value === 'string') continue;
+    if (value && typeof value === 'object' && typeof value.match === 'string') continue;
+    errors.push(`boundaries.modules.${name}: must be a glob string or { match: "<glob>" }`);
+  }
+}
 
-  if (!config || typeof config !== 'object') {
-    return { valid: false, errors: ['boundaries config must be an object'] };
+/**
+ * Validate the `preset` field of a boundary config.
+ * @param {string|null|undefined} preset
+ * @param {string[]} errors - Mutated: push any validation errors
+ */
+function validatePreset(preset, errors) {
+  if (preset == null) return;
+  if (typeof preset !== 'string' || !PRESETS[preset]) {
+    errors.push(
+      `boundaries.preset: must be one of ${Object.keys(PRESETS).join(', ')} (got "${preset}")`,
+    );
   }
+}
 
-  // Validate modules
-  if (
-    !config.modules ||
-    typeof config.modules !== 'object' ||
-    Object.keys(config.modules).length === 0
-  ) {
-    errors.push('boundaries.modules must be a non-empty object');
-  } else {
-    for (const [name, value] of Object.entries(config.modules)) {
-      if (typeof value === 'string') continue;
-      if (value && typeof value === 'object' && typeof value.match === 'string') continue;
-      errors.push(`boundaries.modules.${name}: must be a glob string or { match: "<glob>" }`);
+/**
+ * Validate a single rule's target list (`notTo` or `onlyTo`).
+ * @param {*} list - The target list value
+ * @param {string} field - "notTo" or "onlyTo"
+ * @param {number} idx - Rule index for error messages
+ * @param {Set<string>} moduleNames
+ * @param {string[]} errors - Mutated
+ */
+function validateTargetList(list, field, idx, moduleNames, errors) {
+  if (!Array.isArray(list)) {
+    errors.push(`boundaries.rules[${idx}]: "${field}" must be an array`);
+    return;
+  }
+  for (const target of list) {
+    if (!moduleNames.has(target)) {
+      errors.push(`boundaries.rules[${idx}]: "${field}" references unknown module "${target}"`);
     }
   }
+}
 
-  // Validate preset
-  if (config.preset != null) {
-    if (typeof config.preset !== 'string' || !PRESETS[config.preset]) {
-      errors.push(
-        `boundaries.preset: must be one of ${Object.keys(PRESETS).join(', ')} (got "${config.preset}")`,
-      );
+/**
+ * Validate the `rules` array of a boundary config.
+ * @param {Array} rules
+ * @param {object|undefined} modules - The modules config (for cross-referencing names)
+ * @param {string[]} errors - Mutated
+ */
+function validateRules(rules, modules, errors) {
+  if (!rules) return;
+  if (!Array.isArray(rules)) {
+    errors.push('boundaries.rules must be an array');
+    return;
+  }
+  const moduleNames = modules ? new Set(Object.keys(modules)) : new Set();
+  for (let i = 0; i < rules.length; i++) {
+    const rule = rules[i];
+    if (!rule.from) {
+      errors.push(`boundaries.rules[${i}]: missing "from" field`);
+    } else if (!moduleNames.has(rule.from)) {
+      errors.push(`boundaries.rules[${i}]: "from" references unknown module "${rule.from}"`);
+    }
+    if (rule.notTo && rule.onlyTo) {
+      errors.push(`boundaries.rules[${i}]: cannot have both "notTo" and "onlyTo"`);
+    }
+    if (!rule.notTo && !rule.onlyTo) {
+      errors.push(`boundaries.rules[${i}]: must have either "notTo" or "onlyTo"`);
     }
+    if (rule.notTo) validateTargetList(rule.notTo, 'notTo', i, moduleNames, errors);
+    if (rule.onlyTo) validateTargetList(rule.onlyTo, 'onlyTo', i, moduleNames, errors);
   }
+}
 
-  // Validate rules
-  if (config.rules) {
-    if (!Array.isArray(config.rules)) {
-      errors.push('boundaries.rules must be an array');
-    } else {
-      const moduleNames = config.modules ? new Set(Object.keys(config.modules)) : new Set();
-      for (let i = 0; i < config.rules.length; i++) {
-        const rule = config.rules[i];
-        if (!rule.from) {
-          errors.push(`boundaries.rules[${i}]: missing "from" field`);
-        } else if (!moduleNames.has(rule.from)) {
-          errors.push(`boundaries.rules[${i}]: "from" references unknown module "${rule.from}"`);
-        }
-        if (rule.notTo && rule.onlyTo) {
-          errors.push(`boundaries.rules[${i}]: cannot have both "notTo" and "onlyTo"`);
-        }
-        if (!rule.notTo && !rule.onlyTo) {
-          errors.push(`boundaries.rules[${i}]: must have either "notTo" or "onlyTo"`);
-        }
-        if (rule.notTo) {
-          if (!Array.isArray(rule.notTo)) {
-            errors.push(`boundaries.rules[${i}]: "notTo" must be an array`);
-          } else {
-            for (const target of rule.notTo) {
-              if (!moduleNames.has(target)) {
-                errors.push(
-                  `boundaries.rules[${i}]: "notTo" references unknown module "${target}"`,
-                );
-              }
-            }
-          }
-        }
-        if (rule.onlyTo) {
-          if (!Array.isArray(rule.onlyTo)) {
-            errors.push(`boundaries.rules[${i}]: "onlyTo" must be an array`);
-          } else {
-            for (const target of rule.onlyTo) {
-              if (!moduleNames.has(target)) {
-                errors.push(
-                  `boundaries.rules[${i}]: "onlyTo" references unknown module "${target}"`,
-                );
-              }
-            }
-          }
-        }
-      }
+/**
+ * Validate that module layer assignments match preset layers.
+ * @param {object} config
+ * @param {string[]} errors - Mutated
+ */
+function validateLayerAssignments(config, errors) {
+  if (!config.preset || !PRESETS[config.preset] || !config.modules) return;
+  const presetLayers = new Set(PRESETS[config.preset].layers);
+  for (const [name, value] of Object.entries(config.modules)) {
+    if (typeof value === 'object' && value.layer && !presetLayers.has(value.layer)) {
+      errors.push(
+        `boundaries.modules.${name}: layer "${value.layer}" not in preset "${config.preset}" (valid: ${[...presetLayers].join(', ')})`,
+      );
     }
   }
+}
 
-  // Validate preset + layer assignments
-  if (config.preset && PRESETS[config.preset] && config.modules) {
-    const presetLayers = new Set(PRESETS[config.preset].layers);
-    for (const [name, value] of Object.entries(config.modules)) {
-      if (typeof value === 'object' && value.layer) {
-        if (!presetLayers.has(value.layer)) {
-          errors.push(
-            `boundaries.modules.${name}: layer "${value.layer}" not in preset "${config.preset}" (valid: ${[...presetLayers].join(', ')})`,
-          );
-        }
-      }
-    }
+/**
+ * Validate a boundary configuration object.
+ * @param {object} config - The `manifesto.boundaries` config
+ * @returns {{ valid: boolean, errors: string[] }}
+ */
+export function validateBoundaryConfig(config) {
+  if (!config || typeof config !== 'object') {
+    return { valid: false, errors: ['boundaries config must be an object'] };
   }
 
+  const errors = [];
+  validateModules(config.modules, errors);
+  validatePreset(config.preset, errors);
+  validateRules(config.rules, config.modules, errors);
+  validateLayerAssignments(config, errors);
   return { valid: errors.length === 0, errors };
 }