@optave/codegraph 2.6.0 → 3.0.0

package/src/extractors/python.js

@@ -22,12 +22,14 @@ export function extractPythonSymbols(tree, _filePath) {
           const parentClass = findPythonParentClass(node);
           const fullName = parentClass ? `${parentClass}.${nameNode.text}` : nameNode.text;
           const kind = parentClass ? 'method' : 'function';
+          const fnChildren = extractPythonParameters(node);
           definitions.push({
             name: fullName,
             kind,
             line: node.startPosition.row + 1,
             endLine: nodeEndLine(node),
             decorators,
+            children: fnChildren.length > 0 ? fnChildren : undefined,
           });
         }
         break;
@@ -36,11 +38,13 @@ export function extractPythonSymbols(tree, _filePath) {
       case 'class_definition': {
         const nameNode = node.childForFieldName('name');
         if (nameNode) {
+          const clsChildren = extractPythonClassProperties(node);
           definitions.push({
             name: nameNode.text,
             kind: 'class',
             line: node.startPosition.row + 1,
             endLine: nodeEndLine(node),
+            children: clsChildren.length > 0 ? clsChildren : undefined,
           });
           const superclasses =
             node.childForFieldName('superclasses') || findChild(node, 'argument_list');
@@ -108,6 +112,24 @@ export function extractPythonSymbols(tree, _filePath) {
         break;
       }
 
+      case 'expression_statement': {
+        // Module-level UPPER_CASE assignments → constants
+        if (node.parent && node.parent.type === 'module') {
+          const assignment = findChild(node, 'assignment');
+          if (assignment) {
+            const left = assignment.childForFieldName('left');
+            if (left && left.type === 'identifier' && /^[A-Z_][A-Z0-9_]*$/.test(left.text)) {
+              definitions.push({
+                name: left.text,
+                kind: 'constant',
+                line: node.startPosition.row + 1,
+              });
+            }
+          }
+        }
+        break;
+      }
+
       case 'import_from_statement': {
         let source = '';
         const names = [];
@@ -133,6 +155,118 @@ export function extractPythonSymbols(tree, _filePath) {
     for (let i = 0; i < node.childCount; i++) walkPythonNode(node.child(i));
   }
 
+  function extractPythonParameters(fnNode) {
+    const params = [];
+    const paramsNode = fnNode.childForFieldName('parameters') || findChild(fnNode, 'parameters');
+    if (!paramsNode) return params;
+    for (let i = 0; i < paramsNode.childCount; i++) {
+      const child = paramsNode.child(i);
+      if (!child) continue;
+      const t = child.type;
+      if (t === 'identifier') {
+        params.push({ name: child.text, kind: 'parameter', line: child.startPosition.row + 1 });
+      } else if (
+        t === 'typed_parameter' ||
+        t === 'default_parameter' ||
+        t === 'typed_default_parameter'
+      ) {
+        const nameNode = child.childForFieldName('name') || child.child(0);
+        if (nameNode && nameNode.type === 'identifier') {
+          params.push({
+            name: nameNode.text,
+            kind: 'parameter',
+            line: child.startPosition.row + 1,
+          });
+        }
+      } else if (t === 'list_splat_pattern' || t === 'dictionary_splat_pattern') {
+        // *args, **kwargs
+        for (let j = 0; j < child.childCount; j++) {
+          const inner = child.child(j);
+          if (inner && inner.type === 'identifier') {
+            params.push({ name: inner.text, kind: 'parameter', line: child.startPosition.row + 1 });
+            break;
+          }
+        }
+      }
+    }
+    return params;
+  }
+
+  function extractPythonClassProperties(classNode) {
+    const props = [];
+    const seen = new Set();
+    const body = classNode.childForFieldName('body') || findChild(classNode, 'block');
+    if (!body) return props;
+
+    for (let i = 0; i < body.childCount; i++) {
+      const child = body.child(i);
+      if (!child) continue;
+
+      // Direct class attribute assignments: x = 5
+      if (child.type === 'expression_statement') {
+        const assignment = findChild(child, 'assignment');
+        if (assignment) {
+          const left = assignment.childForFieldName('left');
+          if (left && left.type === 'identifier' && !seen.has(left.text)) {
+            seen.add(left.text);
+            props.push({ name: left.text, kind: 'property', line: child.startPosition.row + 1 });
+          }
+        }
+      }
+
+      // __init__ method: self.x = ... assignments
+      if (child.type === 'function_definition') {
+        const fnName = child.childForFieldName('name');
+        if (fnName && fnName.text === '__init__') {
+          const initBody = child.childForFieldName('body') || findChild(child, 'block');
+          if (initBody) {
+            walkInitBody(initBody, seen, props);
+          }
+        }
+      }
+
+      // decorated __init__
+      if (child.type === 'decorated_definition') {
+        for (let j = 0; j < child.childCount; j++) {
+          const inner = child.child(j);
+          if (inner && inner.type === 'function_definition') {
+            const fnName = inner.childForFieldName('name');
+            if (fnName && fnName.text === '__init__') {
+              const initBody = inner.childForFieldName('body') || findChild(inner, 'block');
+              if (initBody) {
+                walkInitBody(initBody, seen, props);
+              }
+            }
+          }
+        }
+      }
+    }
+    return props;
+  }
+
+  function walkInitBody(bodyNode, seen, props) {
+    for (let i = 0; i < bodyNode.childCount; i++) {
+      const stmt = bodyNode.child(i);
+      if (!stmt || stmt.type !== 'expression_statement') continue;
+      const assignment = findChild(stmt, 'assignment');
+      if (!assignment) continue;
+      const left = assignment.childForFieldName('left');
+      if (!left || left.type !== 'attribute') continue;
+      const obj = left.childForFieldName('object');
+      const attr = left.childForFieldName('attribute');
+      if (
+        obj &&
+        obj.text === 'self' &&
+        attr &&
+        attr.type === 'identifier' &&
+        !seen.has(attr.text)
+      ) {
+        seen.add(attr.text);
+        props.push({ name: attr.text, kind: 'property', line: stmt.startPosition.row + 1 });
+      }
+    }
+  }
+
   function findPythonParentClass(node) {
     let current = node.parent;
     while (current) {

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/index.js

@@ -5,16 +5,35 @@
  *   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 } from './batch.js';
+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
@@ -37,6 +56,7 @@ export {
   computeHalsteadMetrics,
   computeLOCMetrics,
   computeMaintainabilityIndex,
+  findFunctionNode,
   HALSTEAD_RULES,
   iterComplexity,
 } from './complexity.js';
@@ -46,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,
@@ -71,8 +100,15 @@ export {
   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
@@ -91,13 +127,21 @@ 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,
@@ -106,9 +150,11 @@ export {
   iterWhere,
   kindIcon,
   moduleMapData,
+  normalizeSymbol,
   pathData,
   queryNameData,
   rolesData,
+  STRUCTURAL_EDGE_KINDS,
   statsData,
   VALID_ROLES,
   whereData,
@@ -147,5 +193,7 @@ export {
 } 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';