agentmap 0.5.0 → 0.7.0

package/dist/cli.js

@@ -20,14 +20,15 @@ cli
     .command('[dir]', 'Generate a YAML map of the codebase')
     .option('-o, --output <file>', 'Write output to file (default: stdout)')
     .option('-i, --ignore <pattern>', 'Ignore pattern (can be repeated)', { type: [] })
-    .option('-d, --diff', 'Include git diff status for definitions (added/updated, +N-M)')
+    .option('-f, --filter <pattern>', 'Filter pattern - only include matching files (can be repeated)', { type: [] })
     .action(async (dir, options) => {
     const targetDir = resolve(dir ?? '.');
     try {
         const map = await generateMap({
             dir: targetDir,
             ignore: options.ignore,
-            diff: options.diff,
+            filter: options.filter,
+            diff: true,
         });
         // Check if map is empty (only has root key with empty object)
         const rootKey = Object.keys(map)[0];
@@ -39,7 +40,8 @@ cli
         const yaml = await generateMapYaml({
             dir: targetDir,
             ignore: options.ignore,
-            diff: options.diff,
+            filter: options.filter,
+            diff: true,
         });
         if (options.output) {
             await writeFile(options.output, yaml, 'utf8');
@@ -64,11 +66,12 @@ If you find well-separated packages, use the Task tool to process them concurren
 
 For each package/area, identify the most important files - entry points, core modules, main utilities, and key abstractions.
 
-For each important file, add a descriptive comment at the very top (before any imports or code). The comment should:
+For each important file, add a descriptive comment at the top (before any imports or code). The comment should:
 - Be 2-4 lines describing what the file does and why it exists
 - Use the appropriate comment style for the language (// for JS/TS, # for Python, //! for Rust modules, etc.)
 - If the file is an entry point (CLI, main, server start, etc.), mark it as such in the description
 - If the file already has a top comment, review and update it to be accurate and descriptive - don't skip it
+- If the file has a shebang (#!/...), keep it as the first line and add the description comment immediately after
 
 Examples:
 
@@ -84,6 +87,11 @@ Rust:
 //! HTTP server module.
 //! Entry point for the web API, configures routes and middleware.
 
+With shebang (shell scripts, node CLI, etc.):
+#!/usr/bin/env node
+// CLI entrypoint for the build tool.
+// Handles argument parsing and runs the build pipeline.
+
 After adding comments to all important files, run \`npx -y agentmap\` to verify the files appear in the generated map.
 
 You can run this prompt again anytime to keep file descriptions up to date as the codebase evolves.

package/dist/cli.js.map

@@ -1 +1 @@
-{"version":3,"file":"cli.js","sourceRoot":"","sources":["../src/cli.ts"],"names":[],"mappings":";AACA,+CAA+C;AAE/C,OAAO,EAAE,SAAS,EAAE,MAAM,aAAa,CAAA;AACvC,OAAO,EAAE,OAAO,EAAE,MAAM,MAAM,CAAA;AAC9B,OAAO,EAAE,GAAG,EAAE,MAAM,KAAK,CAAA;AACzB,OAAO,EAAE,WAAW,EAAE,eAAe,EAAE,MAAM,YAAY,CAAA;AAEzD,MAAM,GAAG,GAAG,GAAG,CAAC,UAAU,CAAC,CAAA;AAE3B,MAAM,gBAAgB,GAAG;;;;;;;;;;CAUxB,CAAA;AAED,GAAG;KACA,OAAO,CAAC,OAAO,EAAE,qCAAqC,CAAC;KACvD,MAAM,CAAC,qBAAqB,EAAE,wCAAwC,CAAC;KACvE,MAAM,CAAC,wBAAwB,EAAE,kCAAkC,EAAE,EAAE,IAAI,EAAE,EAAE,EAAE,CAAC;KAClF,MAAM,CAAC,YAAY,EAAE,+DAA+D,CAAC;KACrF,MAAM,CAAC,KAAK,EAAE,GAAuB,EAAE,OAA+D,EAAE,EAAE;IACzG,MAAM,SAAS,GAAG,OAAO,CAAC,GAAG,IAAI,GAAG,CAAC,CAAA;IAErC,IAAI,CAAC;QACH,MAAM,GAAG,GAAG,MAAM,WAAW,CAAC;YAC5B,GAAG,EAAE,SAAS;YACd,MAAM,EAAE,OAAO,CAAC,MAAM;YACtB,IAAI,EAAE,OAAO,CAAC,IAAI;SACnB,CAAC,CAAA;QAEF,8DAA8D;QAC9D,MAAM,OAAO,GAAG,MAAM,CAAC,IAAI,CAAC,GAAG,CAAC,CAAC,CAAC,CAAC,CAAA;QACnC,MAAM,SAAS,GAAG,GAAG,CAAC,OAAO,CAAC,CAAA;QAC9B,IAAI,CAAC,SAAS,IAAI,MAAM,CAAC,IAAI,CAAC,SAAS,CAAC,CAAC,MAAM,KAAK,CAAC,EAAE,CAAC;YACtD,OAAO,CAAC,KAAK,CAAC,gBAAgB,CAAC,CAAA;YAC/B,OAAO,CAAC,IAAI,CAAC,CAAC,CAAC,CAAA;QACjB,CAAC;QAED,MAAM,IAAI,GAAG,MAAM,eAAe,CAAC;YACjC,GAAG,EAAE,SAAS;YACd,MAAM,EAAE,OAAO,CAAC,MAAM;YACtB,IAAI,EAAE,OAAO,CAAC,IAAI;SACnB,CAAC,CAAA;QAEF,IAAI,OAAO,CAAC,MAAM,EAAE,CAAC;YACnB,MAAM,SAAS,CAAC,OAAO,CAAC,MAAM,EAAE,IAAI,EAAE,MAAM,CAAC,CAAA;YAC7C,OAAO,CAAC,KAAK,CAAC,gBAAgB,OAAO,CAAC,MAAM,EAAE,CAAC,CAAA;QACjD,CAAC;aAAM,CAAC;YACN,OAAO,CAAC,GAAG,CAAC,IAAI,CAAC,CAAA;QACnB,CAAC;IACH,CAAC;IAAC,OAAO,GAAG,EAAE,CAAC;QACb,OAAO,CAAC,KAAK,CAAC,QAAQ,EAAE,GAAG,YAAY,KAAK,CAAC,CAAC,CAAC,GAAG,CAAC,OAAO,CAAC,CAAC,CAAC,GAAG,CAAC,CAAA;QACjE,OAAO,CAAC,IAAI,CAAC,CAAC,CAAC,CAAA;IACjB,CAAC;AACH,CAAC,CAAC,CAAA;AAEJ,MAAM,WAAW,GAAG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;6DAyCyC,CAAA;AAE7D,GAAG;KACA,OAAO,CAAC,QAAQ,EAAE,2DAA2D,CAAC;KAC9E,MAAM,CAAC,GAAG,EAAE;IACX,OAAO,CAAC,GAAG,CAAC,WAAW,CAAC,CAAA;AAC1B,CAAC,CAAC,CAAA;AAEJ,GAAG,CAAC,IAAI,EAAE,CAAA;AACV,GAAG,CAAC,OAAO,CAAC,OAAO,CAAC,CAAA;AAEpB,GAAG,CAAC,KAAK,EAAE,CAAA"}
+{"version":3,"file":"cli.js","sourceRoot":"","sources":["../src/cli.ts"],"names":[],"mappings":"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"}

package/dist/extract/definitions.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"definitions.d.ts","sourceRoot":"","sources":["../../src/extract/definitions.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,UAAU,EAAkB,QAAQ,EAAE,UAAU,EAAE,MAAM,aAAa,CAAA;AAgFnF;;GAEG;AACH,wBAAgB,kBAAkB,CAChC,QAAQ,EAAE,UAAU,EACpB,QAAQ,EAAE,QAAQ,GACjB,UAAU,EAAE,CA8Bd"}
+{"version":3,"file":"definitions.d.ts","sourceRoot":"","sources":["../../src/extract/definitions.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,UAAU,EAAkB,QAAQ,EAAE,UAAU,EAAE,MAAM,aAAa,CAAA;AAuCnF;;GAEG;AACH,wBAAgB,kBAAkB,CAChC,QAAQ,EAAE,UAAU,EACpB,QAAQ,EAAE,QAAQ,GACjB,UAAU,EAAE,CAoCd"}

package/dist/extract/definitions.js

@@ -1,384 +1,263 @@
 // Extract top-level definitions using tree-sitter.
+import { FUNCTION_TYPES, CLASS_TYPES, STRUCT_TYPES, TRAIT_TYPES, INTERFACE_TYPES, TYPE_TYPES, ENUM_TYPES, CONST_TYPES, extractName, extractConstName, isExported, unwrapExport, isExtern, isZigConst, getZigTypeDeclaration, } from '../languages/index.js';
 /**
  * Minimum body lines for a function/class to be included in defs
  */
 const MIN_BODY_LINES = 5;
-/**
- * Node types that represent functions per language
- */
-const FUNCTION_TYPES = {
-    typescript: ['function_declaration', 'method_definition'],
-    javascript: ['function_declaration', 'method_definition'],
-    python: ['function_definition'],
-    rust: ['function_item'],
-    go: ['function_declaration', 'method_declaration'],
-};
-/**
- * Node types that represent classes per language
- */
-const CLASS_TYPES = {
-    typescript: ['class_declaration', 'abstract_class_declaration'],
-    javascript: ['class_declaration'],
-    python: ['class_definition'],
-    rust: ['struct_item', 'impl_item', 'trait_item'],
-    go: ['type_declaration'],
-};
-/**
- * Node types that represent interfaces per language
- */
-const INTERFACE_TYPES = {
-    typescript: ['interface_declaration'],
-    javascript: [],
-    python: [],
-    rust: ['trait_item'],
-    go: [],
-};
-/**
- * Node types that represent type aliases per language
- */
-const TYPE_TYPES = {
-    typescript: ['type_alias_declaration'],
-    javascript: [],
-    python: [],
-    rust: ['type_item'],
-    go: ['type_declaration'],
-};
-/**
- * Node types that represent enums per language
- */
-const ENUM_TYPES = {
-    typescript: ['enum_declaration'],
-    javascript: [],
-    python: [],
-    rust: ['enum_item'],
-    go: [],
-};
-/**
- * Node types that represent constants per language
- */
-const CONST_TYPES = {
-    typescript: ['lexical_declaration'],
-    javascript: ['lexical_declaration'],
-    python: [], // Python constants handled separately
-    rust: ['const_item', 'static_item'],
-    go: ['const_declaration', 'var_declaration'],
-};
-/**
- * Check if a node is an exported statement
- */
-function isExported(node) {
-    return node.type === 'export_statement';
-}
 /**
  * Extract top-level definitions from a syntax tree
  */
 export function extractDefinitions(rootNode, language) {
     const definitions = [];
     const seenNames = new Set();
-    // Walk immediate children of root (top-level only)
     for (let i = 0; i < rootNode.childCount; i++) {
         const node = rootNode.child(i);
         if (!node)
             continue;
-        const exported = isExported(node);
-        const actualNode = unwrapExport(node);
-        // Try to extract definition
-        const def = extractDefinition(actualNode, language, exported);
-        if (def && !seenNames.has(def.name)) {
-            definitions.push(def);
-            seenNames.add(def.name);
+        // Handle C++ linkage_specification (extern "C" { ... })
+        if (language === 'cpp' && node.type === 'linkage_specification') {
+            for (let j = 0; j < node.childCount; j++) {
+                const inner = node.child(j);
+                if (!inner)
+                    continue;
+                if (inner.type === 'extern' || inner.type === 'string_literal')
+                    continue;
+                const defs = extractDefinition({ node: inner, language, forceExtern: true });
+                for (const def of defs) {
+                    if (!seenNames.has(def.name)) {
+                        definitions.push(def);
+                        seenNames.add(def.name);
+                    }
+                }
+            }
+            continue;
         }
-        // Handle multiple declarations in one statement (e.g., const a = 1, b = 2)
-        const extraDefs = extractMultipleDeclarations(actualNode, language, exported);
-        for (const d of extraDefs) {
-            if (!seenNames.has(d.name)) {
-                definitions.push(d);
-                seenNames.add(d.name);
+        const defs = extractDefinition({ node, language });
+        for (const def of defs) {
+            if (!seenNames.has(def.name)) {
+                definitions.push(def);
+                seenNames.add(def.name);
             }
         }
     }
     return definitions;
 }
 /**
- * Extract a single definition from a node
+ * Extract definition(s) from a single node.
+ * Handles export detection, unwrapping, and multiple declarations internally.
  */
-function extractDefinition(node, language, exported) {
+function extractDefinition(opts) {
+    const { node, language, forceExtern = false } = opts;
+    // Determine exported status and get actual node to process
+    let exported;
+    let actualNode;
+    let nodeIsExtern = forceExtern;
+    switch (language) {
+        case 'typescript':
+        case 'javascript':
+            exported = isExported(node, language);
+            actualNode = unwrapExport(node, language);
+            break;
+        case 'zig':
+            exported = isExported(node, language);
+            actualNode = node;
+            nodeIsExtern = nodeIsExtern || isExtern(node, language);
+            break;
+        case 'rust':
+            exported = isExported(node, language);
+            actualNode = node;
+            break;
+        case 'go':
+            // Go: exported determined per-name (uppercase = exported)
+            // We'll handle this in createDefinition
+            exported = false; // placeholder, resolved per-name
+            actualNode = node;
+            break;
+        case 'cpp':
+            exported = false; // C++ doesn't have module exports in this sense
+            actualNode = node;
+            nodeIsExtern = nodeIsExtern || isExtern(node, language);
+            break;
+        case 'python':
+        default:
+            exported = false;
+            actualNode = node;
+            break;
+    }
+    const results = [];
+    // Helper to resolve export status (Go uses name-based exports)
+    const resolveExported = (name) => {
+        if (language === 'go')
+            return isExported(node, language, name);
+        return exported;
+    };
+    // Helper to create a definition
+    const createDef = (name, type, startLine, endLine) => ({
+        name,
+        line: startLine,
+        endLine,
+        type,
+        exported: resolveExported(name),
+        ...(nodeIsExtern ? { extern: true } : {})
+    });
     const functionTypes = FUNCTION_TYPES[language];
     const classTypes = CLASS_TYPES[language];
+    const structTypes = STRUCT_TYPES[language];
+    const traitTypes = TRAIT_TYPES[language];
     const interfaceTypes = INTERFACE_TYPES[language];
     const typeTypes = TYPE_TYPES[language];
     const enumTypes = ENUM_TYPES[language];
     const constTypes = CONST_TYPES[language];
     // Functions
-    if (functionTypes.includes(node.type)) {
-        const name = extractName(node, language);
-        if (name && getBodyLineCount(node) > MIN_BODY_LINES) {
-            return {
-                name,
-                line: node.startPosition.row + 1,
-                endLine: node.endPosition.row + 1,
-                type: 'function',
-                exported
-            };
+    if (functionTypes.includes(actualNode.type)) {
+        const name = extractName(actualNode, language);
+        if (name && getBodyLineCount(actualNode) > MIN_BODY_LINES) {
+            results.push(createDef(name, 'function', actualNode.startPosition.row + 1, actualNode.endPosition.row + 1));
         }
+        return results;
     }
     // Classes
-    if (classTypes.includes(node.type)) {
-        const name = extractName(node, language);
-        if (name && getBodyLineCount(node) > MIN_BODY_LINES) {
-            return {
-                name,
-                line: node.startPosition.row + 1,
-                endLine: node.endPosition.row + 1,
-                type: 'class',
-                exported
-            };
+    if (classTypes.includes(actualNode.type)) {
+        const name = extractName(actualNode, language);
+        if (name && getBodyLineCount(actualNode) > MIN_BODY_LINES) {
+            results.push(createDef(name, 'class', actualNode.startPosition.row + 1, actualNode.endPosition.row + 1));
+        }
+        return results;
+    }
+    // Structs
+    if (structTypes.includes(actualNode.type)) {
+        const name = extractName(actualNode, language);
+        if (name && getBodyLineCount(actualNode) > MIN_BODY_LINES) {
+            results.push(createDef(name, 'struct', actualNode.startPosition.row + 1, actualNode.endPosition.row + 1));
+        }
+        return results;
+    }
+    // Traits
+    if (traitTypes.includes(actualNode.type)) {
+        const name = extractName(actualNode, language);
+        if (name && getBodyLineCount(actualNode) > MIN_BODY_LINES) {
+            results.push(createDef(name, 'trait', actualNode.startPosition.row + 1, actualNode.endPosition.row + 1));
         }
+        return results;
     }
     // Interfaces
-    if (interfaceTypes.includes(node.type)) {
-        const name = extractName(node, language);
+    if (interfaceTypes.includes(actualNode.type)) {
+        const name = extractName(actualNode, language);
         if (name) {
-            return {
-                name,
-                line: node.startPosition.row + 1,
-                endLine: node.endPosition.row + 1,
-                type: 'interface',
-                exported
-            };
+            results.push(createDef(name, 'interface', actualNode.startPosition.row + 1, actualNode.endPosition.row + 1));
         }
+        return results;
     }
     // Type aliases
-    if (typeTypes.includes(node.type)) {
-        const name = extractName(node, language);
+    if (typeTypes.includes(actualNode.type)) {
+        const name = extractName(actualNode, language);
         if (name) {
-            return {
-                name,
-                line: node.startPosition.row + 1,
-                endLine: node.endPosition.row + 1,
-                type: 'type',
-                exported
-            };
+            results.push(createDef(name, 'type', actualNode.startPosition.row + 1, actualNode.endPosition.row + 1));
         }
+        return results;
     }
     // Enums
-    if (enumTypes.includes(node.type)) {
-        const name = extractName(node, language);
+    if (enumTypes.includes(actualNode.type)) {
+        const name = extractName(actualNode, language);
         if (name) {
-            return {
-                name,
-                line: node.startPosition.row + 1,
-                endLine: node.endPosition.row + 1,
-                type: 'enum',
-                exported
-            };
+            results.push(createDef(name, 'enum', actualNode.startPosition.row + 1, actualNode.endPosition.row + 1));
         }
+        return results;
     }
-    // Constants/variables (only if exported for TS/JS)
-    if (constTypes.includes(node.type)) {
-        // For TS/JS, only include if exported
-        if ((language === 'typescript' || language === 'javascript') && !exported) {
-            // Check for arrow functions assigned to const (these are always included if large enough)
-            const arrowFn = extractArrowFunction(node);
-            if (arrowFn && arrowFn.bodyLines > MIN_BODY_LINES) {
-                return {
-                    name: arrowFn.name,
-                    line: arrowFn.line,
-                    endLine: arrowFn.endLine,
-                    type: 'function',
-                    exported: false
-                };
+    // Constants/variables
+    if (constTypes.includes(actualNode.type)) {
+        // Zig: pub const (may be struct/enum/union or plain const)
+        if (language === 'zig') {
+            if (!exported || !isZigConst(actualNode)) {
+                return results;
             }
-            return null;
-        }
-        // Check for arrow functions first
-        const arrowFn = extractArrowFunction(node);
-        if (arrowFn && arrowFn.bodyLines > MIN_BODY_LINES) {
-            return {
-                name: arrowFn.name,
-                line: arrowFn.line,
-                endLine: arrowFn.endLine,
-                type: 'function',
-                exported
-            };
-        }
-        // Otherwise it's a constant
-        const name = extractConstName(node, language);
-        if (name) {
-            return {
-                name,
-                line: node.startPosition.row + 1,
-                endLine: node.endPosition.row + 1,
-                type: 'const',
-                exported
-            };
-        }
-    }
-    return null;
-}
-/**
- * Extract multiple declarations from a single statement
- */
-function extractMultipleDeclarations(node, language, exported) {
-    const defs = [];
-    // Handle lexical_declaration with multiple variable_declarators
-    if (node.type === 'lexical_declaration') {
-        if ((language === 'typescript' || language === 'javascript') && !exported) {
-            return defs;
+            const name = extractName(actualNode, language);
+            if (name) {
+                // Use specific type if struct/enum/union, otherwise const
+                const zigType = getZigTypeDeclaration(actualNode);
+                const type = zigType ?? 'const';
+                results.push(createDef(name, type, actualNode.startPosition.row + 1, actualNode.endPosition.row + 1));
+            }
+            return results;
         }
-        let count = 0;
-        for (let i = 0; i < node.childCount; i++) {
-            const child = node.child(i);
-            if (child?.type === 'variable_declarator') {
-                count++;
-                if (count > 1) {
-                    const nameNode = child.childForFieldName('name');
-                    const valueNode = child.childForFieldName('value');
-                    if (nameNode) {
-                        const isArrowFn = valueNode?.type === 'arrow_function';
-                        const type = isArrowFn ? 'function' : 'const';
-                        // Skip small arrow functions
-                        if (isArrowFn && valueNode && getBodyLineCount(valueNode) <= MIN_BODY_LINES) {
-                            continue;
-                        }
-                        defs.push({
-                            name: nameNode.text,
-                            line: child.startPosition.row + 1,
-                            endLine: child.endPosition.row + 1,
-                            type,
-                            exported,
-                        });
-                    }
+        // TS/JS: handle arrow functions and multiple declarations
+        if (language === 'typescript' || language === 'javascript') {
+            // Non-exported: only include large arrow functions
+            if (!exported) {
+                const arrowFn = extractArrowFunction(actualNode);
+                if (arrowFn && arrowFn.bodyLines > MIN_BODY_LINES) {
+                    results.push({
+                        name: arrowFn.name,
+                        line: arrowFn.line,
+                        endLine: arrowFn.endLine,
+                        type: 'function',
+                        exported: false
+                    });
                 }
+                return results;
             }
+            // Exported: extract all declarations
+            return extractJSDeclarations({ node: actualNode, language, exported, isExtern: nodeIsExtern });
         }
-    }
-    return defs;
-}
-/**
- * Unwrap export statement to get the actual declaration
- */
-function unwrapExport(node) {
-    if (node.type === 'export_statement') {
-        for (let i = 0; i < node.childCount; i++) {
-            const child = node.child(i);
-            if (!child)
-                continue;
-            if (child.type !== 'export' && !child.type.includes('comment') && child.type !== 'default') {
-                return child;
-            }
+        // Other languages: simple const extraction
+        const name = extractConstName(actualNode, language);
+        if (name) {
+            results.push(createDef(name, 'const', actualNode.startPosition.row + 1, actualNode.endPosition.row + 1));
         }
+        return results;
     }
-    return node;
+    return results;
 }
 /**
- * Extract the name from a definition node
+ * Extract all declarations from a TS/JS lexical_declaration
+ * Handles: const a = 1, const b = () => {}, const c = 1, d = 2
  */
-function extractName(node, language) {
-    // Try to find 'name' field first
-    const nameNode = node.childForFieldName('name');
-    if (nameNode) {
-        return nameNode.text;
-    }
-    // Language-specific fallbacks
-    switch (language) {
-        case 'typescript':
-        case 'javascript':
-            return extractJSName(node);
-        case 'python':
-            return extractPythonName(node);
-        case 'rust':
-            return extractRustName(node);
-        case 'go':
-            return extractGoName(node);
-    }
-    return null;
-}
-/**
- * Extract name from a const/let declaration
- */
-function extractConstName(node, language) {
-    if (language === 'typescript' || language === 'javascript') {
-        for (let i = 0; i < node.childCount; i++) {
-            const child = node.child(i);
-            if (child?.type === 'variable_declarator') {
-                const nameNode = child.childForFieldName('name');
-                return nameNode?.text ?? null;
-            }
-        }
-    }
-    if (language === 'rust') {
-        return extractName(node, language);
-    }
-    if (language === 'go') {
-        // Look for const_spec or var_spec
-        for (let i = 0; i < node.childCount; i++) {
-            const child = node.child(i);
-            if (child?.type === 'const_spec' || child?.type === 'var_spec') {
-                const nameNode = child.childForFieldName('name');
-                return nameNode?.text ?? null;
-            }
+function extractJSDeclarations(opts) {
+    const { node, exported, isExtern: nodeIsExtern } = opts;
+    const results = [];
+    if (node.type !== 'lexical_declaration') {
+        // Single const extraction fallback
+        const name = extractConstName(node, opts.language);
+        if (name) {
+            results.push({
+                name,
+                line: node.startPosition.row + 1,
+                endLine: node.endPosition.row + 1,
+                type: 'const',
+                exported,
+                ...(nodeIsExtern ? { extern: true } : {})
+            });
         }
+        return results;
     }
-    return null;
-}
-function extractJSName(node) {
     for (let i = 0; i < node.childCount; i++) {
         const child = node.child(i);
-        if (!child)
+        if (child?.type !== 'variable_declarator')
+            continue;
+        const nameNode = child.childForFieldName('name');
+        const valueNode = child.childForFieldName('value');
+        if (!nameNode)
+            continue;
+        const isArrowFn = valueNode?.type === 'arrow_function';
+        const type = isArrowFn ? 'function' : 'const';
+        // Skip small arrow functions
+        if (isArrowFn && valueNode && getBodyLineCount(valueNode) <= MIN_BODY_LINES) {
             continue;
-        if (child.type === 'identifier' || child.type === 'type_identifier') {
-            return child.text;
-        }
-        if (child.type === 'property_identifier') {
-            return child.text;
-        }
-    }
-    return null;
-}
-function extractPythonName(node) {
-    for (let i = 0; i < node.childCount; i++) {
-        const child = node.child(i);
-        if (child?.type === 'identifier') {
-            return child.text;
-        }
-    }
-    return null;
-}
-function extractRustName(node) {
-    if (node.type === 'impl_item') {
-        const typeNode = node.childForFieldName('type');
-        if (typeNode) {
-            const ident = typeNode.type === 'type_identifier'
-                ? typeNode
-                : findChild(typeNode, 'type_identifier');
-            return ident?.text ?? null;
-        }
-    }
-    for (let i = 0; i < node.childCount; i++) {
-        const child = node.child(i);
-        if (child?.type === 'identifier' || child?.type === 'type_identifier') {
-            return child.text;
-        }
-    }
-    return null;
-}
-function extractGoName(node) {
-    if (node.type === 'type_declaration') {
-        const spec = findChild(node, 'type_spec');
-        if (spec) {
-            const nameNode = spec.childForFieldName('name');
-            return nameNode?.text ?? null;
-        }
-    }
-    for (let i = 0; i < node.childCount; i++) {
-        const child = node.child(i);
-        if (child?.type === 'identifier' || child?.type === 'field_identifier') {
-            return child.text;
         }
+        results.push({
+            name: nameNode.text,
+            line: child.startPosition.row + 1,
+            endLine: child.endPosition.row + 1,
+            type,
+            exported,
+            ...(nodeIsExtern ? { extern: true } : {})
+        });
     }
-    return null;
+    return results;
 }
+// ============================================================================
+// Utility functions
+// ============================================================================
 /**
  * Extract arrow function assigned to const/let
  */