flowseeker 0.1.7 → 0.1.8

package/dist/index/structuredExtractor.js

@@ -3,6 +3,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.detectLanguage = detectLanguage;
 exports.extractStructuredNodes = extractStructuredNodes;
 exports.getDeclarationSnippet = getDeclarationSnippet;
+const treeSitterExtractor_1 = require("./treeSitterExtractor");
 const maxStructuredLineChars = 12000;
 const languagePatterns = {
     typescript: {
@@ -21,25 +22,37 @@ const languagePatterns = {
         comment: /\/\*\*[\s\S]*?\*\/|\/\/.*$/gm,
         annotation: /@\w+/g
     },
+    dart: {
+        extensions: [".dart"],
+        // class, enum, extension, mixin, abstract class, factory
+        declaration: /^\s*(?:abstract\s+)?(?:class|enum|extension|mixin)\s+(\w+)|^\s*(?:const\s+)?(?:final\s+)?(?:static\s+)?(?:Future\s*<\s*\w+\s*>\s+)?(?:void|bool|int|double|String|num|dynamic|Widget)\??\s+(\w+)\s*\([^)]*\)\s*\{?|^\s*(?:Future\s*<\s*\w+\s*>\s+)?\w+\??\s+(\w+)\s*\([^)]*\)\s*\{?/gm,
+        call: /(\w+(?:\.\w+)*)\s*\(/g,
+        stringLiteral: /(["'])((?:\\.|(?!\1).)*?)\1/g,
+        comment: /\/\*[\s\S]*?\*\/|\/\/.*$/gm,
+        annotation: /@\w+(?:\([^)]*\))?/g
+    },
     python: {
         extensions: [".py"],
-        declaration: /^\s*(?:async\s+)?(?:def|class)\s+(\w+)/gm,
+        // async def, def, class; also capture decorators and Django URL patterns
+        declaration: /^\s*(?:async\s+)?(?:def|class)\s+(\w+)|^\s*@\w+(?:\.\w+)*(?:\([^)]*\))?\s*\n?\s*(?:async\s+)?(?:def|class)\s+(\w+)/gm,
         call: /(\w+(?:\.\w+)*)\s*\(/g,
         stringLiteral: /(["'])((?:\\.|(?!\1).)*?)\1/g,
         comment: /#.*$/gm,
-        annotation: /@\w+/g
+        annotation: /@\w+(?:\.\w+)*(?:\([^)]*\))?/g
     },
     php: {
         extensions: [".php"],
-        declaration: /^\s*(?:(?:public|private|protected|static)\s+)*function\s+(\w+)/gm,
-        call: /(\w+(?:->\w+)*(?:::w+)*)\s*\(/g,
+        // class, interface, trait; also catch Laravel-named classes and methods
+        declaration: /^\s*(?:(?:abstract|final)\s+)?(?:class|interface|trait)\s+(\w+)|^\s*(?:(?:public|private|protected|static)\s+)*function\s+(\w+)/gm,
+        call: /(\w+(?:->\w+)*(?:::\w+)*)\s*\(/g,
         stringLiteral: /(["'])((?:\\.|(?!\1).)*?)\1/g,
         comment: /\/\*\*[\s\S]*?\*\/|\/\/.*$|#.*$/gm,
         annotation: /#\[[\s\S]*?\]|@\w+/g
     },
     java: {
         extensions: [".java"],
-        declaration: /^\s*(?:(?:public|private|protected|static|final|abstract)\s+)*(?:class|interface|enum)\s+(\w+)/gm,
+        // class, interface, enum; also capture Spring-annotated methods and constructors
+        declaration: /^\s*(?:(?:public|private|protected|static|final|abstract)\s+)*(?:class|interface|enum)\s+(\w+)|^\s*(?:@\w+(?:\([^)]*\))?\s*)*(?:(?:public|private|protected|static|final|abstract)\s+)*(?:<[^>]+>\s+)?(?:\w+(?:<[^>]+>)?)\s+(\w+)\s*\([^)]*\)\s*(?:throws\s+\w+(?:\s*,\s*\w+)*)?\s*\{?/gm,
         call: /(\w+(?:\.\w+)*)\s*\(/g,
         stringLiteral: /"((?:\\.|[^"\\])*)"/g,
         comment: /\/\*\*[\s\S]*?\*\/|\/\/.*$/gm,
@@ -47,7 +60,8 @@ const languagePatterns = {
     },
     go: {
         extensions: [".go"],
-        declaration: /^\s*func\s+(?:\(\w+\s+\*?\w+\)\s+)?(\w+)/gm,
+        // func declarations, methods with pointer/value receivers, type struct/interface
+        declaration: /^\s*func\s+(?:\(\w+\s+\*?\w+\)\s+)?(\w+)\s*\(|^\s*type\s+(\w+)\s+(?:struct|interface)\s*\{/gm,
         call: /(\w+(?:\.\w+)*)\s*\(/g,
         stringLiteral: /"((?:\\.|[^"\\])*)"|`[^`]*`/g,
         comment: /\/\/.*$/gm,
@@ -72,7 +86,7 @@ const languagePatterns = {
     rust: {
         extensions: [".rs"],
         declaration: /^\s*(?:pub\s+)?(?:async\s+)?fn\s+(\w+)/gm,
-        call: /(\w+(?:::w+)*(?:\.\w+)*)\s*\(/g,
+        call: /(\w+(?:::\w+)*(?:\.\w+)*)\s*\(/g,
         stringLiteral: /"((?:\\.|[^"\\])*)"/g,
         comment: /\/\/.*$|\/\/!.*$/gm,
         annotation: /#\[[\s\S]*?\]/g
@@ -95,7 +109,15 @@ function detectLanguage(filePath) {
     }
     return undefined;
 }
-function extractStructuredNodes(content, language) {
+function extractStructuredNodes(content, language, relativePath = "") {
+    // Try tree-sitter parser first for supported languages
+    if ((0, treeSitterExtractor_1.supportsTreeSitterLanguage)(language)) {
+        const tsResult = (0, treeSitterExtractor_1.extractWithTreeSitter)(content, language, relativePath);
+        if (tsResult) {
+            return convertTreeSitterResult(tsResult, relativePath).map((n) => ({ ...n, extractorKind: "tree-sitter" }));
+        }
+    }
+    // Fall back to structured regex
     const patterns = languagePatterns[language];
     if (!patterns) {
         return [];
@@ -103,11 +125,127 @@ function extractStructuredNodes(content, language) {
     const lines = content.split(/\r?\n/);
     const nodes = [];
     nodes.push(...extractDeclarations(lines, patterns.declaration, language));
+    nodes.push(...extractMethodDeclarations(lines, language));
     nodes.push(...extractCalls(lines, patterns.call));
     nodes.push(...extractStringLiterals(lines, patterns.stringLiteral));
     nodes.push(...extractComments(lines, patterns.comment));
     nodes.push(...extractAnnotations(lines, patterns.annotation));
-    return dedupeNodes(nodes);
+    nodes.push(...extractLanguageSpecific(lines, language));
+    return dedupeNodes(assignParentFqns(nodes)).map((n) => ({ ...n, extractorKind: "structured-regex" }));
+}
+function extractLanguageSpecific(lines, language) {
+    const nodes = [];
+    // Dart: extract import statements
+    if (language === "dart") {
+        const importRe = /^\s*import\s+['"]([^'"]+)['"]\s*;?/;
+        const exportRe = /^\s*export\s+['"]([^'"]+)['"]\s*;?/;
+        const partRe = /^\s*part\s+['"]([^'"]+)['"]\s*;?/;
+        lines.forEach((line, index) => {
+            if (line.length > maxStructuredLineChars)
+                return;
+            let m = importRe.exec(line) || exportRe.exec(line) || partRe.exec(line);
+            if (m) {
+                nodes.push({ kind: "import", name: m[1], range: { startLine: index + 1, endLine: index + 1 }, text: line.trim() });
+            }
+        });
+    }
+    // Go: extract var/const blocks and import blocks
+    if (language === "go") {
+        lines.forEach((line, index) => {
+            if (line.length > maxStructuredLineChars)
+                return;
+            // Package-level var or const
+            if (/^\s*var\s+(\w+)/.test(line)) {
+                const m = line.match(/^\s*var\s+(\w+)/);
+                if (m)
+                    nodes.push({ kind: "declaration", name: m[1], fqn: m[1], symbolKind: "constant", range: { startLine: index + 1, endLine: index + 1 }, text: line.trim() });
+            }
+            if (/^\s*const\s+(\w+)/.test(line)) {
+                const m = line.match(/^\s*const\s+(\w+)/);
+                if (m)
+                    nodes.push({ kind: "declaration", name: m[1], fqn: m[1], symbolKind: "constant", range: { startLine: index + 1, endLine: index + 1 }, text: line.trim() });
+            }
+        });
+    }
+    // PHP: extract use (namespace import) statements
+    if (language === "php") {
+        const useRe = /^\s*use\s+([\w\\]+?)(?:\s+as\s+\w+)?\s*;/;
+        const nsRe = /^\s*namespace\s+([\w\\]+)\s*;/;
+        lines.forEach((line, index) => {
+            if (line.length > maxStructuredLineChars)
+                return;
+            let m = useRe.exec(line);
+            if (m) {
+                const fqn = m[1].trim();
+                const shortName = fqn.split("\\").pop() || fqn;
+                nodes.push({ kind: "import", name: shortName, fqn, range: { startLine: index + 1, endLine: index + 1 }, text: line.trim() });
+                return;
+            }
+            m = nsRe.exec(line);
+            if (m) {
+                nodes.push({ kind: "declaration", name: m[1], fqn: m[1], symbolKind: "class", range: { startLine: index + 1, endLine: index + 1 }, text: line.trim() });
+            }
+        });
+    }
+    // Java: extract import statements
+    if (language === "java") {
+        const importRe = /^\s*import\s+(?:static\s+)?([\w.]+(?:\.\*)?)\s*;/;
+        lines.forEach((line, index) => {
+            if (line.length > maxStructuredLineChars)
+                return;
+            const m = importRe.exec(line);
+            if (m) {
+                const pkg = m[1].trim();
+                const shortName = pkg.split(".").pop() || pkg;
+                nodes.push({ kind: "import", name: shortName, fqn: pkg, range: { startLine: index + 1, endLine: index + 1 }, text: line.trim() });
+            }
+        });
+    }
+    // Python: extract Django URL patterns and import statements
+    if (language === "python") {
+        const importRe = /^\s*(?:from\s+(\S+)\s+import\s+\S+|import\s+(\S+))/;
+        lines.forEach((line, index) => {
+            if (line.length > maxStructuredLineChars)
+                return;
+            const m = importRe.exec(line);
+            if (m) {
+                const name = m[1] || m[2];
+                if (name) {
+                    const shortName = name.split(".").pop() || name;
+                    nodes.push({ kind: "import", name: shortName, fqn: name, range: { startLine: index + 1, endLine: index + 1 }, text: line.trim() });
+                }
+            }
+        });
+    }
+    // Go: extract import blocks
+    if (language === "go") {
+        const importRe = /^\s*"([^"]+)"\s*\/\/?\s*(\w+)?/;
+        let inImportBlock = false;
+        lines.forEach((line, index) => {
+            if (/^\s*import\s*\(/.test(line)) {
+                inImportBlock = true;
+                return;
+            }
+            if (inImportBlock && /^\s*\)/.test(line)) {
+                inImportBlock = false;
+                return;
+            }
+            if (/^\s*import\s+"([^"]+)"/.test(line)) {
+                const m = line.match(/^\s*import\s+"([^"]+)"/);
+                if (m)
+                    nodes.push({ kind: "import", name: m[1].split("/").pop() || m[1], fqn: m[1], range: { startLine: index + 1, endLine: index + 1 }, text: line.trim() });
+                return;
+            }
+            if (inImportBlock) {
+                const m = importRe.exec(line.trim());
+                if (m) {
+                    const alias = m[2] || m[1].split("/").pop() || m[1];
+                    nodes.push({ kind: "import", name: alias, fqn: m[1], range: { startLine: index + 1, endLine: index + 1 }, text: line.trim() });
+                }
+            }
+        });
+    }
+    return nodes;
 }
 function extractDeclarations(lines, pattern, language) {
     const nodes = [];
@@ -118,13 +256,16 @@ function extractDeclarations(lines, pattern, language) {
         pattern.lastIndex = 0;
         let match = pattern.exec(line);
         while (match) {
-            const name = match[1];
+            const name = match[1] ?? match[2];
             const isExported = /\bexport\b/.test(line) || /\bpub\b/.test(line) || /\bpublic\b/.test(line);
             const nodeKind = isClassDecl(line, language) ? "declaration" : "declaration";
+            const declarationKind = inferSymbolKind(line, language);
             nodes.push({
                 kind: nodeKind,
                 name,
-                range: { startLine: index + 1, endLine: index + 1 },
+                fqn: name,
+                symbolKind: declarationKind,
+                range: { startLine: index + 1, endLine: expandDeclarationEnd(lines, index, language) },
                 text: line.trim(),
                 parent: isExported ? "exported" : undefined
             });
@@ -133,6 +274,34 @@ function extractDeclarations(lines, pattern, language) {
     });
     return nodes;
 }
+function extractMethodDeclarations(lines, language) {
+    if (!methodLanguages.has(language)) {
+        return [];
+    }
+    const nodes = [];
+    const pattern = /^\s*(?:(?:public|private|protected|static|async|readonly|override)\s+)*(\w+)\s*\([^)]*\)\s*(?::[^={]+)?\s*[{:]?/;
+    lines.forEach((line, index) => {
+        if (line.length > maxStructuredLineChars || /\b(function|if|for|while|switch|catch|return|class|interface|type|enum)\b/.test(line)) {
+            return;
+        }
+        const match = line.match(pattern);
+        const name = match?.[1];
+        if (!name || commonNonMethodNames.has(name)) {
+            return;
+        }
+        nodes.push({
+            kind: "declaration",
+            name,
+            fqn: name,
+            symbolKind: "method",
+            range: { startLine: index + 1, endLine: expandDeclarationEnd(lines, index, language) },
+            text: line.trim()
+        });
+    });
+    return nodes;
+}
+const methodLanguages = new Set(["typescript", "javascript", "python", "php", "java", "csharp", "kotlin", "dart"]);
+const commonNonMethodNames = new Set(["if", "for", "while", "switch", "catch", "return", "function", "class", "interface", "type", "enum"]);
 function isClassDecl(line, language) {
     const classKeywords = {
         typescript: /\bclass\b/,
@@ -141,10 +310,75 @@ function isClassDecl(line, language) {
         php: /\bclass\b/,
         java: /\bclass\b/,
         csharp: /\bclass\b/,
-        kotlin: /\bclass\b/
+        kotlin: /\bclass\b/,
+        dart: /\bclass\b/,
+        go: /\bstruct\b|\binterface\b/
     };
     return classKeywords[language]?.test(line) ?? false;
 }
+function inferSymbolKind(line, language) {
+    if (/\bclass\b/.test(line)) {
+        return "class";
+    }
+    if (/\binterface\b|\btrait\b/.test(line)) {
+        return "interface";
+    }
+    if (/\btype\b/.test(line)) {
+        return "type";
+    }
+    if (/\bstruct\b/.test(line)) {
+        return "type";
+    }
+    if (/\benum\b/.test(line)) {
+        return "constant";
+    }
+    if (/\bextension\b/.test(line)) {
+        return "class";
+    }
+    if (/\bmixin\b/.test(line) && language === "dart") {
+        return "class";
+    }
+    if (/\bconst\b/.test(line) && /=>|function\s*\(/.test(line)) {
+        return "function";
+    }
+    if (/\bconst\b/.test(line)) {
+        return "constant";
+    }
+    if (/\bfunction\b|\bdef\b|\bfunc\b|\bfn\b/.test(line)) {
+        return "function";
+    }
+    return "function";
+}
+function expandDeclarationEnd(lines, startIndex, language) {
+    if (language === "python") {
+        const baseIndent = leadingSpaces(lines[startIndex]);
+        for (let index = startIndex + 1; index < Math.min(lines.length, startIndex + 200); index += 1) {
+            const line = lines[index];
+            if (line.trim() && leadingSpaces(line) <= baseIndent) {
+                return index;
+            }
+        }
+        return Math.min(lines.length, startIndex + 80);
+    }
+    let depth = 0;
+    for (let index = startIndex; index < Math.min(lines.length, startIndex + 240); index += 1) {
+        for (const char of lines[index]) {
+            if (char === "{") {
+                depth += 1;
+            }
+            else if (char === "}") {
+                depth -= 1;
+            }
+        }
+        if (index > startIndex && depth <= 0) {
+            return index + 1;
+        }
+    }
+    return startIndex + 1;
+}
+function leadingSpaces(line) {
+    return line.match(/^\s*/)?.[0].length ?? 0;
+}
 function extractCalls(lines, pattern) {
     const nodes = [];
     const callNames = new Set();
@@ -235,6 +469,29 @@ function extractAnnotations(lines, pattern) {
     });
     return nodes.slice(0, 40);
 }
+function assignParentFqns(nodes) {
+    const declarations = nodes
+        .filter((node) => node.kind === "declaration" && node.name)
+        .sort((left, right) => left.range.startLine - right.range.startLine || right.range.endLine - left.range.endLine);
+    return nodes.map((node) => {
+        if (node.kind !== "declaration" || !node.name || node.symbolKind === "class" || node.symbolKind === "interface") {
+            return node;
+        }
+        const parent = declarations
+            .filter((candidate) => candidate !== node && (candidate.symbolKind === "class" || candidate.symbolKind === "interface"))
+            .filter((candidate) => candidate.range.startLine <= node.range.startLine && candidate.range.endLine >= node.range.endLine)
+            .sort((left, right) => (right.range.startLine - left.range.startLine) || (left.range.endLine - right.range.endLine))[0];
+        if (!parent?.name) {
+            return node;
+        }
+        return {
+            ...node,
+            parentFqn: parent.fqn ?? parent.name,
+            fqn: `${parent.fqn ?? parent.name}.${node.name}`,
+            symbolKind: node.symbolKind === "function" ? "method" : node.symbolKind
+        };
+    });
+}
 function dedupeNodes(nodes) {
     const seen = new Set();
     const result = [];
@@ -253,4 +510,38 @@ function getDeclarationSnippet(content, node, contextLines = 5) {
     const end = Math.min(lines.length, node.range.endLine + contextLines);
     return lines.slice(start, end).join("\n");
 }
+function convertTreeSitterResult(result, relativePath) {
+    if (!result)
+        return [];
+    const nodes = [];
+    const kindMap = {
+        function: "function",
+        method: "method",
+        class: "class",
+        interface: "interface",
+        type: "type",
+        constant: "constant",
+        declaration: "declaration"
+    };
+    for (const symbol of result.symbols) {
+        nodes.push({
+            kind: "declaration",
+            name: symbol.name,
+            fqn: symbol.fqn,
+            symbolKind: kindMap[symbol.kind] ?? "declaration",
+            range: { startLine: symbol.line, endLine: symbol.endLine },
+            text: symbol.name,
+            parentFqn: symbol.parentFqn
+        });
+    }
+    for (const call of result.calls) {
+        nodes.push({
+            kind: "call",
+            name: call.to,
+            range: { startLine: 1, endLine: 1 },
+            text: call.to
+        });
+    }
+    return dedupeNodes(nodes);
+}
 //# sourceMappingURL=structuredExtractor.js.map

package/dist/index/treeSitterExtractor.js

@@ -0,0 +1,264 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.supportsTreeSitterLanguage = supportsTreeSitterLanguage;
+exports.extractWithTreeSitter = extractWithTreeSitter;
+let tsLanguage;
+let tsxLanguage;
+let loadAttempted = false;
+function loadTreeSitter() {
+    if (loadAttempted)
+        return tsLanguage !== undefined;
+    loadAttempted = true;
+    try {
+        const Parser = require("tree-sitter");
+        const TS = require("tree-sitter-typescript");
+        tsLanguage = TS.typescript;
+        tsxLanguage = TS.tsx;
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+function supportsTreeSitterLanguage(language) {
+    if (!loadTreeSitter())
+        return false;
+    return language === "typescript" || language === "javascript" || language === "tsx" || language === "jsx";
+}
+function extractWithTreeSitter(content, language, relativePath) {
+    if (!loadTreeSitter())
+        return undefined;
+    if (!supportsTreeSitterLanguage(language))
+        return undefined;
+    try {
+        const Parser = require("tree-sitter");
+        const parser = new Parser();
+        const lang = language === "tsx" || language === "jsx" ? tsxLanguage : tsLanguage;
+        if (!lang)
+            return undefined;
+        parser.setLanguage(lang);
+        const tree = parser.parse(content);
+        const root = tree.rootNode;
+        const symbols = [];
+        const calls = [];
+        const imports = [];
+        extractFromNode(root, content, relativePath, symbols, calls, imports, "");
+        return {
+            extractorKind: "tree-sitter",
+            language,
+            parserVersion: "tree-sitter-1",
+            symbols: symbols.slice(0, 200),
+            imports: imports.slice(0, 100),
+            calls: calls.slice(0, 200)
+        };
+    }
+    catch (err) {
+        return undefined;
+    }
+}
+function extractFromNode(node, content, relativePath, symbols, calls, imports, parentFqn) {
+    if (!node || !node.type)
+        return;
+    try {
+        switch (node.type) {
+            case "function_declaration":
+            case "generator_function_declaration": {
+                const name = childText(node, "identifier") || childText(node, "name");
+                if (name) {
+                    const fqn = parentFqn ? `${parentFqn}.${name}` : name;
+                    symbols.push({
+                        id: `${relativePath}:${fqn}:${node.startPosition.row + 1}`,
+                        name,
+                        fqn,
+                        kind: parentFqn ? "method" : "function",
+                        line: node.startPosition.row + 1,
+                        endLine: node.endPosition.row + 1,
+                        exported: false,
+                        parentFqn: parentFqn || undefined
+                    });
+                    extractChildren(node, content, relativePath, symbols, calls, imports, fqn);
+                    return;
+                }
+                break;
+            }
+            case "class_declaration": {
+                const name = childText(node, "type_identifier") || childText(node, "identifier") || childText(node, "name");
+                if (name) {
+                    const fqn = parentFqn ? `${parentFqn}.${name}` : name;
+                    symbols.push({
+                        id: `${relativePath}:${fqn}:${node.startPosition.row + 1}`,
+                        name,
+                        fqn,
+                        kind: "class",
+                        line: node.startPosition.row + 1,
+                        endLine: node.endPosition.row + 1,
+                        exported: false,
+                        parentFqn: parentFqn || undefined
+                    });
+                    extractChildren(node, content, relativePath, symbols, calls, imports, fqn);
+                    return;
+                }
+                break;
+            }
+            case "method_definition": {
+                const name = childText(node, "property_identifier") || childText(node, "name");
+                if (name && parentFqn) {
+                    const fqn = `${parentFqn}.${name}`;
+                    symbols.push({
+                        id: `${relativePath}:${fqn}:${node.startPosition.row + 1}`,
+                        name,
+                        fqn,
+                        kind: "method",
+                        line: node.startPosition.row + 1,
+                        endLine: node.endPosition.row + 1,
+                        exported: false,
+                        parentFqn
+                    });
+                    extractChildren(node, content, relativePath, symbols, calls, imports, fqn);
+                    return;
+                }
+                break;
+            }
+            case "variable_declarator": {
+                const name = childText(node, "identifier") || childText(node, "name");
+                const value = findChild(node, "arrow_function") || findChild(node, "function_expression");
+                if (name && value) {
+                    const fqn = parentFqn ? `${parentFqn}.${name}` : name;
+                    symbols.push({
+                        id: `${relativePath}:${fqn}:${node.startPosition.row + 1}`,
+                        name,
+                        fqn,
+                        kind: parentFqn ? "method" : "function",
+                        line: node.startPosition.row + 1,
+                        endLine: node.endPosition.row + 1,
+                        exported: false,
+                        parentFqn: parentFqn || undefined
+                    });
+                    extractChildren(node, content, relativePath, symbols, calls, imports, fqn);
+                    return;
+                }
+                break;
+            }
+            case "call_expression": {
+                const funcName = extractCallName(node);
+                if (funcName) {
+                    calls.push({
+                        id: `${relativePath}:call:${funcName}:${node.startPosition.row + 1}`,
+                        type: "callee",
+                        from: parentFqn || relativePath,
+                        to: funcName,
+                        fromPath: relativePath,
+                        toPath: "",
+                        weight: 0.65,
+                        reason: `calls ${funcName}`
+                    });
+                }
+                break;
+            }
+            case "import_statement": {
+                const source = childText(node, "string")?.replace(/^["']|["']$/g, "");
+                if (source) {
+                    const specifiers = collectImportSpecifiers(node);
+                    imports.push({
+                        source,
+                        importedNames: specifiers,
+                        resolvedPath: undefined,
+                        relativePath,
+                        line: node.startPosition.row + 1
+                    });
+                }
+                return; // Don't recurse into imports
+            }
+            case "export_statement": {
+                // Mark the exported declaration
+                const decl = findChild(node, "function_declaration") || findChild(node, "class_declaration") ||
+                    findChild(node, "variable_declaration") || findChild(node, "lexical_declaration");
+                if (decl) {
+                    extractFromNode(decl, content, relativePath, symbols, calls, imports, parentFqn);
+                    // Tag last symbol as exported
+                    if (symbols.length > 0) {
+                        symbols[symbols.length - 1] = { ...symbols[symbols.length - 1], exported: true };
+                    }
+                }
+                return;
+            }
+        }
+    }
+    catch {
+        // Skip malformed nodes
+    }
+    // Recurse into children for unhandled node types
+    extractChildren(node, content, relativePath, symbols, calls, imports, parentFqn);
+}
+function extractChildren(node, content, relativePath, symbols, calls, imports, parentFqn) {
+    if (!node.children)
+        return;
+    for (const child of node.children) {
+        extractFromNode(child, content, relativePath, symbols, calls, imports, parentFqn);
+    }
+}
+function childText(node, type) {
+    if (!node.children)
+        return undefined;
+    for (const child of node.children) {
+        if (child.type === type)
+            return child.text;
+    }
+    return undefined;
+}
+function findChild(node, type) {
+    if (!node.children)
+        return undefined;
+    for (const child of node.children) {
+        if (child.type === type)
+            return child;
+    }
+    if (node.namedChildren) {
+        for (const child of node.namedChildren) {
+            if (child.type === type)
+                return child;
+        }
+    }
+    return undefined;
+}
+function extractCallName(node) {
+    if (!node.children)
+        return undefined;
+    for (const child of node.children) {
+        if (child.type === "identifier")
+            return child.text;
+        if (child.type === "member_expression") {
+            // e.g. obj.method() -> return "method"
+            const parts = [];
+            for (const mc of child.children) {
+                if (mc.type === "property_identifier")
+                    parts.push(mc.text);
+                else if (mc.type === "identifier")
+                    parts.push(mc.text);
+            }
+            if (parts.length > 0)
+                return parts[parts.length - 1];
+        }
+    }
+    return undefined;
+}
+function collectImportSpecifiers(node) {
+    const names = [];
+    if (!node.children)
+        return names;
+    for (const child of node.children) {
+        if (child.type === "import_specifier" || child.type === "named_imports") {
+            if (child.children) {
+                for (const spec of child.children) {
+                    if (spec.type === "identifier")
+                        names.push(spec.text);
+                }
+            }
+        }
+        if (child.type === "namespace_import") {
+            names.push("*");
+        }
+    }
+    return names;
+}
+//# sourceMappingURL=treeSitterExtractor.js.map