@optave/codegraph 2.5.1 → 3.0.0

package/src/extractors/ruby.js

@@ -31,11 +31,13 @@ export function extractRubySymbols(tree, _filePath) {
       case 'class': {
         const nameNode = node.childForFieldName('name');
         if (nameNode) {
+          const classChildren = extractRubyClassChildren(node);
           definitions.push({
             name: nameNode.text,
             kind: 'class',
             line: node.startPosition.row + 1,
             endLine: nodeEndLine(node),
+            children: classChildren.length > 0 ? classChildren : undefined,
           });
           const superclass = node.childForFieldName('superclass');
           if (superclass) {
@@ -73,11 +75,13 @@ export function extractRubySymbols(tree, _filePath) {
       case 'module': {
         const nameNode = node.childForFieldName('name');
         if (nameNode) {
+          const moduleChildren = extractRubyBodyConstants(node);
           definitions.push({
             name: nameNode.text,
             kind: 'module',
             line: node.startPosition.row + 1,
             endLine: nodeEndLine(node),
+            children: moduleChildren.length > 0 ? moduleChildren : undefined,
           });
         }
         break;
@@ -88,11 +92,13 @@ export function extractRubySymbols(tree, _filePath) {
         if (nameNode) {
           const parentClass = findRubyParentClass(node);
           const fullName = parentClass ? `${parentClass}.${nameNode.text}` : nameNode.text;
+          const params = extractRubyParameters(node);
           definitions.push({
             name: fullName,
             kind: 'method',
             line: node.startPosition.row + 1,
             endLine: nodeEndLine(node),
+            children: params.length > 0 ? params : undefined,
           });
         }
         break;
@@ -103,16 +109,34 @@ export function extractRubySymbols(tree, _filePath) {
         if (nameNode) {
           const parentClass = findRubyParentClass(node);
           const fullName = parentClass ? `${parentClass}.${nameNode.text}` : nameNode.text;
+          const params = extractRubyParameters(node);
           definitions.push({
             name: fullName,
             kind: 'function',
             line: node.startPosition.row + 1,
             endLine: nodeEndLine(node),
+            children: params.length > 0 ? params : undefined,
           });
         }
         break;
       }
 
+      case 'assignment': {
+        // Top-level constant assignments (parent is program)
+        if (node.parent && node.parent.type === 'program') {
+          const left = node.childForFieldName('left');
+          if (left && left.type === 'constant') {
+            definitions.push({
+              name: left.text,
+              kind: 'constant',
+              line: node.startPosition.row + 1,
+              endLine: nodeEndLine(node),
+            });
+          }
+        }
+        break;
+      }
+
       case 'call': {
         const methodNode = node.childForFieldName('method');
         if (methodNode) {
@@ -186,3 +210,68 @@ export function extractRubySymbols(tree, _filePath) {
   walkRubyNode(tree.rootNode);
   return { definitions, calls, imports, classes, exports };
 }
+
+// ── Child extraction helpers ────────────────────────────────────────────────
+
+const RUBY_PARAM_TYPES = new Set([
+  'identifier',
+  'optional_parameter',
+  'splat_parameter',
+  'hash_splat_parameter',
+  'block_parameter',
+  'keyword_parameter',
+]);
+
+function extractRubyParameters(methodNode) {
+  const params = [];
+  const paramList =
+    methodNode.childForFieldName('parameters') || findChild(methodNode, 'method_parameters');
+  if (!paramList) return params;
+  for (let i = 0; i < paramList.childCount; i++) {
+    const param = paramList.child(i);
+    if (!param || !RUBY_PARAM_TYPES.has(param.type)) continue;
+    let name;
+    if (param.type === 'identifier') {
+      name = param.text;
+    } else {
+      // Compound parameter types have an identifier child for the name
+      const id = findChild(param, 'identifier');
+      name = id ? id.text : param.text;
+    }
+    params.push({ name, kind: 'parameter', line: param.startPosition.row + 1 });
+  }
+  return params;
+}
+
+function extractRubyBodyConstants(containerNode) {
+  const children = [];
+  const body = containerNode.childForFieldName('body') || findChild(containerNode, 'body');
+  if (!body) return children;
+  for (let i = 0; i < body.childCount; i++) {
+    const child = body.child(i);
+    if (!child || child.type !== 'assignment') continue;
+    const left = child.childForFieldName('left');
+    if (left && left.type === 'constant') {
+      children.push({ name: left.text, kind: 'constant', line: child.startPosition.row + 1 });
+    }
+  }
+  return children;
+}
+
+function extractRubyClassChildren(classNode) {
+  const children = [];
+  const body = classNode.childForFieldName('body') || findChild(classNode, 'body');
+  if (!body) return children;
+  for (let i = 0; i < body.childCount; i++) {
+    const child = body.child(i);
+    if (!child || child.type !== 'assignment') continue;
+    const left = child.childForFieldName('left');
+    if (!left) continue;
+    if (left.type === 'instance_variable') {
+      children.push({ name: left.text, kind: 'property', line: child.startPosition.row + 1 });
+    } else if (left.type === 'constant') {
+      children.push({ name: left.text, kind: 'constant', line: child.startPosition.row + 1 });
+    }
+  }
+  return children;
+}

package/src/extractors/rust.js

@@ -1,4 +1,4 @@
-import { nodeEndLine } from './helpers.js';
+import { findChild, nodeEndLine } from './helpers.js';
 
 /**
  * Extract symbols from Rust files.
@@ -30,11 +30,13 @@ export function extractRustSymbols(tree, _filePath) {
           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,
           });
         }
         break;
@@ -43,11 +45,13 @@ export function extractRustSymbols(tree, _filePath) {
       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,
           });
         }
         break;
@@ -56,11 +60,26 @@ export function extractRustSymbols(tree, _filePath) {
       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;
+      }
+
+      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;
@@ -170,6 +189,57 @@ export function extractRustSymbols(tree, _filePath) {
   return { definitions, calls, imports, classes, exports };
 }
 
+// ── Child extraction helpers ────────────────────────────────────────────────
+
+function extractRustParameters(paramListNode) {
+  const params = [];
+  if (!paramListNode) return params;
+  for (let i = 0; i < paramListNode.childCount; i++) {
+    const param = paramListNode.child(i);
+    if (!param) continue;
+    if (param.type === 'self_parameter') {
+      params.push({ name: 'self', kind: 'parameter', line: param.startPosition.row + 1 });
+    } else if (param.type === 'parameter') {
+      const pattern = param.childForFieldName('pattern');
+      if (pattern) {
+        params.push({ name: pattern.text, kind: 'parameter', line: param.startPosition.row + 1 });
+      }
+    }
+  }
+  return params;
+}
+
+function extractStructFields(structNode) {
+  const fields = [];
+  const fieldList =
+    structNode.childForFieldName('body') || findChild(structNode, 'field_declaration_list');
+  if (!fieldList) return fields;
+  for (let i = 0; i < fieldList.childCount; i++) {
+    const field = fieldList.child(i);
+    if (!field || field.type !== 'field_declaration') continue;
+    const nameNode = field.childForFieldName('name');
+    if (nameNode) {
+      fields.push({ name: nameNode.text, kind: 'property', line: field.startPosition.row + 1 });
+    }
+  }
+  return fields;
+}
+
+function extractEnumVariants(enumNode) {
+  const variants = [];
+  const body = enumNode.childForFieldName('body') || findChild(enumNode, 'enum_variant_list');
+  if (!body) return variants;
+  for (let i = 0; i < body.childCount; i++) {
+    const variant = body.child(i);
+    if (!variant || variant.type !== 'enum_variant') continue;
+    const nameNode = variant.childForFieldName('name');
+    if (nameNode) {
+      variants.push({ name: nameNode.text, kind: 'constant', line: variant.startPosition.row + 1 });
+    }
+  }
+  return variants;
+}
+
 function extractRustUsePath(node) {
   if (!node) return [];
 

package/src/flow.js

@@ -6,7 +6,7 @@
  */
 
 import { openReadonlyOrFail } from './db.js';
-import { paginateResult } from './paginate.js';
+import { paginateResult, printNdjson } from './paginate.js';
 import { isTestFile, kindIcon } from './queries.js';
 import { FRAMEWORK_ENTRY_PREFIXES } from './structure.js';
 
@@ -204,7 +204,7 @@ export function flowData(name, dbPath, opts = {}) {
   }
 
   db.close();
-  return {
+  const base = {
     entry,
     depth: maxDepth,
     steps,
@@ -213,6 +213,7 @@ export function flowData(name, dbPath, opts = {}) {
     totalReached: visited.size - 1, // exclude the entry node itself
     truncated,
   };
+  return paginateResult(base, 'steps', { limit: opts.limit, offset: opts.offset });
 }
 
 /**
@@ -293,8 +294,7 @@ export function flow(name, dbPath, opts = {}) {
       offset: opts.offset,
     });
     if (opts.ndjson) {
-      if (data._pagination) console.log(JSON.stringify({ _meta: data._pagination }));
-      for (const e of data.entries) console.log(JSON.stringify(e));
+      printNdjson(data, 'entries');
       return;
     }
     if (opts.json) {

package/src/index.js

@@ -5,10 +5,37 @@
  *   import { buildGraph, queryNameData, findCycles, exportDOT } from 'codegraph';
  */
 
+// AST node queries
+export { AST_NODE_KINDS, astQuery, astQueryData } from './ast.js';
+// Audit (composite report)
+export { audit, auditData } from './audit.js';
+// Batch querying
+export {
+  BATCH_COMMANDS,
+  batch,
+  batchData,
+  batchQuery,
+  multiBatchData,
+  splitTargets,
+} from './batch.js';
+// Architecture boundary rules
+export { evaluateBoundaries, PRESETS, validateBoundaryConfig } from './boundaries.js';
 // Branch comparison
 export { branchCompareData, branchCompareMermaid } from './branch-compare.js';
 // Graph building
 export { buildGraph, collectFiles, loadPathAliases, resolveImportPath } from './builder.js';
+// Control flow graph (intraprocedural)
+export {
+  buildCFGData,
+  buildFunctionCFG,
+  CFG_RULES,
+  cfg,
+  cfgData,
+  cfgToDOT,
+  cfgToMermaid,
+} from './cfg.js';
+// Check (CI validation predicates)
+export { check, checkData } from './check.js';
 // Co-change analysis
 export {
   analyzeCoChanges,
@@ -29,7 +56,9 @@ export {
   computeHalsteadMetrics,
   computeLOCMetrics,
   computeMaintainabilityIndex,
+  findFunctionNode,
   HALSTEAD_RULES,
+  iterComplexity,
 } from './complexity.js';
 // Configuration
 export { loadConfig } from './config.js';
@@ -37,6 +66,15 @@ export { loadConfig } from './config.js';
 export { EXTENSIONS, IGNORE_DIRS, normalizePath } from './constants.js';
 // Circular dependency detection
 export { findCycles, formatCycles } from './cycles.js';
+// Dataflow analysis
+export {
+  buildDataflowEdges,
+  dataflow,
+  dataflowData,
+  dataflowImpactData,
+  dataflowPathData,
+  extractDataflow,
+} from './dataflow.js';
 // Database utilities
 export {
   findDbPath,
@@ -55,13 +93,22 @@ export {
   EMBEDDING_STRATEGIES,
   embed,
   estimateTokens,
+  ftsSearchData,
+  hybridSearchData,
   MODELS,
   multiSearchData,
   search,
   searchData,
 } from './embedder.js';
-// Export (DOT/Mermaid/JSON)
-export { exportDOT, exportJSON, exportMermaid } from './export.js';
+// Export (DOT/Mermaid/JSON/GraphML/GraphSON/Neo4j CSV)
+export {
+  exportDOT,
+  exportGraphML,
+  exportGraphSON,
+  exportJSON,
+  exportMermaid,
+  exportNeo4jCSV,
+} from './export.js';
 // Execution flow tracing
 export { entryPointType, flowData, listEntryPointsData } from './flow.js';
 // Logger
@@ -70,29 +117,44 @@ export { setVerbose } from './logger.js';
 export { manifesto, manifestoData, RULE_DEFS } from './manifesto.js';
 // Native engine
 export { isNativeAvailable } from './native.js';
+// Ownership (CODEOWNERS)
+export { matchOwners, owners, ownersData, ownersForFiles, parseCodeowners } from './owners.js';
 // Pagination utilities
-export { MCP_DEFAULTS, MCP_MAX_LIMIT, paginate, paginateResult } from './paginate.js';
+export { MCP_DEFAULTS, MCP_MAX_LIMIT, paginate, paginateResult, printNdjson } from './paginate.js';
 
 // Unified parser API
 export { getActiveEngine, parseFileAuto, parseFilesAuto } from './parser.js';
 // Query functions (data-returning)
 export {
   ALL_SYMBOL_KINDS,
+  CORE_EDGE_KINDS,
+  CORE_SYMBOL_KINDS,
+  childrenData,
   contextData,
   diffImpactData,
   diffImpactMermaid,
+  EVERY_EDGE_KIND,
+  EVERY_SYMBOL_KIND,
+  EXTENDED_SYMBOL_KINDS,
   explainData,
+  exportsData,
   FALSE_POSITIVE_CALLER_THRESHOLD,
   FALSE_POSITIVE_NAMES,
   fileDepsData,
+  fileExports,
   fnDepsData,
   fnImpactData,
   impactAnalysisData,
+  iterListFunctions,
+  iterRoles,
+  iterWhere,
   kindIcon,
   moduleMapData,
+  normalizeSymbol,
   pathData,
   queryNameData,
   rolesData,
+  STRUCTURAL_EDGE_KINDS,
   statsData,
   VALID_ROLES,
   whereData,
@@ -108,6 +170,15 @@ export {
   saveRegistry,
   unregisterRepo,
 } from './registry.js';
+// Snapshot management
+export {
+  snapshotDelete,
+  snapshotList,
+  snapshotRestore,
+  snapshotSave,
+  snapshotsDir,
+  validateSnapshotName,
+} from './snapshot.js';
 // Structure analysis
 export {
   buildStructure,
@@ -120,5 +191,9 @@ export {
   moduleBoundariesData,
   structureData,
 } from './structure.js';
+// Triage — composite risk audit
+export { triage, triageData } from './triage.js';
+// Interactive HTML viewer
+export { generatePlotHTML, loadPlotConfig } from './viewer.js';
 // Watch mode
 export { watchProject } from './watcher.js';

package/src/manifesto.js

@@ -1,7 +1,9 @@
+import { evaluateBoundaries } from './boundaries.js';
 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';
 
 // ─── Rule Definitions ─────────────────────────────────────────────────
 
@@ -54,6 +56,12 @@ export const RULE_DEFS = [
   { name: 'fanIn', level: 'file', metric: 'fan_in', defaults: { warn: null, fail: null } },
   { name: 'fanOut', level: 'file', metric: 'fan_out', defaults: { warn: null, fail: null } },
   { name: 'noCycles', level: 'graph', metric: 'noCycles', defaults: { warn: null, fail: null } },
+  {
+    name: 'boundaries',
+    level: 'graph',
+    metric: 'boundaries',
+    defaults: { warn: null, fail: null },
+  },
 ];
 
 // ─── Helpers ──────────────────────────────────────────────────────────
@@ -318,6 +326,59 @@ function evaluateGraphRules(db, rules, opts, violations, ruleResults) {
   });
 }
 
+function evaluateBoundaryRules(db, rules, config, opts, violations, ruleResults) {
+  const thresholds = rules.boundaries;
+  const boundaryConfig = config.manifesto?.boundaries;
+
+  // Auto-enable at warn level when boundary config exists but threshold not set
+  const effectiveThresholds = { ...thresholds };
+  if (boundaryConfig && !isEnabled(thresholds)) {
+    effectiveThresholds.warn = true;
+  }
+
+  if (!isEnabled(effectiveThresholds) || !boundaryConfig) {
+    ruleResults.push({
+      name: 'boundaries',
+      level: 'graph',
+      status: 'pass',
+      thresholds: effectiveThresholds,
+      violationCount: 0,
+    });
+    return;
+  }
+
+  const result = evaluateBoundaries(db, boundaryConfig, { noTests: opts.noTests || false });
+  const hasBoundaryViolations = result.violationCount > 0;
+
+  if (!hasBoundaryViolations) {
+    ruleResults.push({
+      name: 'boundaries',
+      level: 'graph',
+      status: 'pass',
+      thresholds: effectiveThresholds,
+      violationCount: 0,
+    });
+    return;
+  }
+
+  const level = effectiveThresholds.fail != null ? 'fail' : 'warn';
+
+  for (const v of result.violations) {
+    violations.push({
+      ...v,
+      level,
+    });
+  }
+
+  ruleResults.push({
+    name: 'boundaries',
+    level: 'graph',
+    status: level,
+    thresholds: effectiveThresholds,
+    violationCount: result.violationCount,
+  });
+}
+
 // ─── Public API ───────────────────────────────────────────────────────
 
 /**
@@ -343,6 +404,7 @@ export function manifestoData(customDbPath, opts = {}) {
     evaluateFunctionRules(db, rules, opts, violations, ruleResults);
     evaluateFileRules(db, rules, opts, violations, ruleResults);
     evaluateGraphRules(db, rules, opts, violations, ruleResults);
+    evaluateBoundaryRules(db, rules, config, opts, violations, ruleResults);
 
     const failViolations = violations.filter((v) => v.level === 'fail');
 
@@ -354,12 +416,13 @@ export function manifestoData(customDbPath, opts = {}) {
       violationCount: violations.length,
     };
 
-    return {
+    const base = {
       rules: ruleResults,
       violations,
       summary,
       passed: failViolations.length === 0,
     };
+    return paginateResult(base, 'violations', { limit: opts.limit, offset: opts.offset });
   } finally {
     db.close();
   }
@@ -371,6 +434,11 @@ 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 (!data.passed) process.exit(1);