attocode 0.2.3 → 0.2.5

package/dist/src/integrations/context/codebase-ast.js

@@ -0,0 +1,818 @@
+/**
+ * Codebase AST Module
+ *
+ * Provides accurate symbol and dependency extraction using tree-sitter AST parsing.
+ * Supports TypeScript/TSX, JavaScript/JSX, Python, and polyglot languages via
+ * pluggable language profiles.
+ *
+ * Key features:
+ * - ASTCache: Parse once per file, extract symbols + dependencies from single tree
+ * - Content-hash invalidation: Detects when file content changes
+ * - Incremental reparse: Leverages tree-sitter's tree.edit() for fast updates
+ * - Polyglot support: Unified LanguageProfile system for adding new languages
+ */
+import * as path from 'path';
+let tsParser = null;
+let tsxParser = null;
+let pyParser = null;
+let parserInitAttempted = false;
+const parserInitFailed = new Set();
+const parsers = new Map();
+export function getParser(ext) {
+    // Check polyglot parser cache first
+    if (parsers.has(ext))
+        return parsers.get(ext);
+    if (parserInitFailed.has(ext))
+        return null;
+    if (!parserInitAttempted) {
+        parserInitAttempted = true;
+        try {
+            // eslint-disable-next-line @typescript-eslint/no-require-imports
+            const Parser = require('tree-sitter');
+            // eslint-disable-next-line @typescript-eslint/no-require-imports
+            const tsLangs = require('tree-sitter-typescript');
+            tsParser = new Parser();
+            tsParser.setLanguage(tsLangs.typescript);
+            tsxParser = new Parser();
+            tsxParser.setLanguage(tsLangs.tsx);
+            try {
+                // eslint-disable-next-line @typescript-eslint/no-require-imports
+                const pyLang = require('tree-sitter-python');
+                pyParser = new Parser();
+                pyParser.setLanguage(pyLang);
+            }
+            catch {
+                // Python grammar not available — not fatal
+            }
+        }
+        catch {
+            // tree-sitter not available at all
+            tsParser = null;
+            tsxParser = null;
+            pyParser = null;
+        }
+    }
+    switch (ext) {
+        case '.ts': return tsParser;
+        case '.tsx': return tsxParser;
+        case '.js': return tsParser; // TS parser handles JS fine
+        case '.jsx': return tsxParser;
+        case '.py': return pyParser;
+        default: {
+            // Try polyglot language profiles (LANGUAGE_PROFILES defined below, accessed lazily at call time)
+            const profile = getLanguageProfile(ext);
+            if (!profile)
+                return null;
+            return initPolyglotParser(ext, profile);
+        }
+    }
+}
+// =============================================================================
+// AST CACHE
+// =============================================================================
+/** Module-level cache: filePath (absolute) -> ParsedFile */
+const astCache = new Map();
+/** Module-level parse counters for diagnostics visibility. */
+let totalParses = 0;
+let cacheHits = 0;
+/** Normalize cache key to absolute path to prevent absolute/relative mismatch. */
+function cacheKey(filePath) {
+    return path.resolve(filePath);
+}
+/**
+ * djb2 string hash — fast, non-cryptographic hash for content invalidation.
+ */
+export function djb2Hash(str) {
+    let hash = 5381;
+    for (let i = 0; i < str.length; i++) {
+        hash = ((hash << 5) + hash + str.charCodeAt(i)) | 0;
+    }
+    return hash >>> 0; // Ensure unsigned
+}
+/**
+ * Parse a file once and extract symbols + dependencies from the same tree.
+ * Results are cached by filePath + contentHash.
+ */
+export function parseFile(content, filePath) {
+    const ext = path.extname(filePath).toLowerCase();
+    const parser = getParser(ext);
+    if (!parser)
+        return null;
+    const hash = djb2Hash(content);
+    const key = cacheKey(filePath);
+    // Check cache
+    const cached = astCache.get(key);
+    if (cached && cached.contentHash === hash) {
+        cacheHits++;
+        return cached;
+    }
+    try {
+        totalParses++;
+        const tree = parser.parse(content);
+        const symbols = extractSymbolsFromRoot(tree.rootNode, ext);
+        const dependencies = extractDependenciesFromRoot(tree.rootNode, ext);
+        const result = { tree, symbols, dependencies, contentHash: hash, parsedAt: Date.now() };
+        astCache.set(key, result);
+        return result;
+    }
+    catch {
+        return null;
+    }
+}
+/**
+ * Full reparse for write_file (no edit ranges available).
+ * Parses from scratch and caches the result.
+ */
+export function fullReparse(filePath, newContent) {
+    return parseFile(newContent, filePath);
+}
+/**
+ * Incremental reparse using tree-sitter's tree.edit() + old tree reference.
+ * Falls back to full reparse if no cached tree is available.
+ */
+export function incrementalReparse(filePath, newContent, edit) {
+    const key = cacheKey(filePath);
+    const cached = astCache.get(key);
+    const ext = path.extname(filePath).toLowerCase();
+    const parser = getParser(ext);
+    if (!parser)
+        return null;
+    try {
+        let newTree;
+        if (cached?.tree?.edit) {
+            // Incremental: edit old tree, reparse with old tree reference
+            cached.tree.edit(edit);
+            newTree = parser.parse(newContent, cached.tree);
+        }
+        else {
+            // No cached tree — full parse
+            newTree = parser.parse(newContent);
+        }
+        const symbols = extractSymbolsFromRoot(newTree.rootNode, ext);
+        const dependencies = extractDependenciesFromRoot(newTree.rootNode, ext);
+        const hash = djb2Hash(newContent);
+        const result = { tree: newTree, symbols, dependencies, contentHash: hash, parsedAt: Date.now() };
+        astCache.set(key, result);
+        return result;
+    }
+    catch {
+        // Fall back to full reparse
+        return parseFile(newContent, filePath);
+    }
+}
+/** Remove a single file from the cache. */
+export function invalidateAST(filePath) { astCache.delete(cacheKey(filePath)); }
+/** Clear all cached parse results. */
+export function clearASTCache() { astCache.clear(); }
+/** Get number of cached files. */
+export function getASTCacheSize() { return astCache.size; }
+/** Get cached parse result without re-parsing. */
+export function getCachedParse(filePath) { return astCache.get(cacheKey(filePath)) ?? null; }
+/** Get AST cache diagnostics stats. */
+export function getASTCacheStats() {
+    const languages = {};
+    for (const [key] of astCache) {
+        const ext = key.slice(key.lastIndexOf('.')).toLowerCase();
+        const lang = ext === '.ts' || ext === '.tsx' ? 'typescript'
+            : ext === '.js' || ext === '.jsx' ? 'javascript'
+                : ext === '.py' ? 'python'
+                    : ext;
+        languages[lang] = (languages[lang] || 0) + 1;
+    }
+    return { fileCount: astCache.size, languages, totalParses, cacheHits };
+}
+/** Reset parse counters (for testing). */
+export function resetASTCacheStats() {
+    totalParses = 0;
+    cacheHits = 0;
+}
+// =============================================================================
+// PUBLIC API
+// =============================================================================
+/**
+ * Check if AST parsing is available for a file extension.
+ */
+export function isASTSupported(filePath) {
+    const ext = path.extname(filePath).toLowerCase();
+    return getParser(ext) !== null;
+}
+/**
+ * Extract symbols from source code using tree-sitter AST.
+ * Uses ASTCache — parses once, reuses cached result.
+ */
+export function extractSymbolsAST(content, filePath) {
+    return parseFile(content, filePath)?.symbols ?? [];
+}
+/**
+ * Extract dependencies from source code using tree-sitter AST.
+ * Uses ASTCache — parses once, reuses cached result.
+ */
+export function extractDependenciesAST(content, filePath) {
+    return parseFile(content, filePath)?.dependencies ?? [];
+}
+// =============================================================================
+// INTERNAL: Root-level extraction dispatchers
+// =============================================================================
+/** Lookup a polyglot language profile by extension. */
+function getLanguageProfile(ext) {
+    return LANGUAGE_PROFILES.find(p => p.extensions.includes(ext));
+}
+function extractSymbolsFromRoot(root, ext) {
+    if (ext === '.py')
+        return extractPythonSymbols(root);
+    const profile = getLanguageProfile(ext);
+    if (profile)
+        return extractSymbolsGeneric(root, profile);
+    return extractTSSymbols(root);
+}
+function extractDependenciesFromRoot(root, ext) {
+    if (ext === '.py')
+        return extractPythonDependencies(root);
+    const profile = getLanguageProfile(ext);
+    if (profile)
+        return extractDependenciesGeneric(root, profile);
+    return extractTSDependencies(root);
+}
+// =============================================================================
+// TYPESCRIPT / JAVASCRIPT EXTRACTION
+// =============================================================================
+function extractTSSymbols(root) {
+    const symbols = [];
+    for (let i = 0; i < root.childCount; i++) {
+        const node = root.child(i);
+        if (!node)
+            continue;
+        if (node.type === 'export_statement') {
+            extractFromExportStatement(node, symbols);
+        }
+        else {
+            // Non-exported top-level declarations
+            const kind = declarationKind(node.type);
+            if (kind) {
+                const name = getDeclarationName(node);
+                if (name) {
+                    symbols.push({
+                        name,
+                        kind,
+                        exported: false,
+                        line: node.startPosition.row + 1,
+                    });
+                }
+            }
+        }
+    }
+    return symbols;
+}
+function extractFromExportStatement(exportNode, symbols) {
+    const decl = exportNode.childForFieldName('declaration');
+    if (decl) {
+        const kind = declarationKind(decl.type);
+        if (kind) {
+            const name = getDeclarationName(decl);
+            if (name) {
+                symbols.push({
+                    name,
+                    kind,
+                    exported: true,
+                    line: decl.startPosition.row + 1,
+                });
+                // Extract class methods
+                if (kind === 'class') {
+                    extractClassMembers(decl, symbols);
+                }
+            }
+        }
+        else if (decl.type === 'lexical_declaration') {
+            // export const x = 1; export let y = 2;
+            for (const child of decl.namedChildren) {
+                if (child.type === 'variable_declarator') {
+                    const nameNode = child.childForFieldName('name');
+                    if (nameNode) {
+                        symbols.push({
+                            name: nameNode.text,
+                            kind: 'variable',
+                            exported: true,
+                            line: child.startPosition.row + 1,
+                        });
+                    }
+                }
+            }
+        }
+        return;
+    }
+    // export { A, B } or export { A, B } from './other'
+    for (let i = 0; i < exportNode.childCount; i++) {
+        const child = exportNode.child(i);
+        if (!child)
+            continue;
+        if (child.type === 'export_clause') {
+            for (const specifier of child.namedChildren) {
+                if (specifier.type === 'export_specifier') {
+                    const nameNode = specifier.childForFieldName('name');
+                    if (nameNode) {
+                        symbols.push({
+                            name: nameNode.text,
+                            kind: 'variable', // We don't know the kind from re-exports
+                            exported: true,
+                            line: specifier.startPosition.row + 1,
+                        });
+                    }
+                }
+            }
+        }
+    }
+    // export default class/function (without declaration field — fallback)
+    let hasDefault = false;
+    for (let i = 0; i < exportNode.childCount; i++) {
+        const child = exportNode.child(i);
+        if (child?.type === 'default')
+            hasDefault = true;
+    }
+    if (hasDefault && !decl) {
+        // Check for inline class/function after 'default'
+        for (let i = 0; i < exportNode.childCount; i++) {
+            const child = exportNode.child(i);
+            if (!child)
+                continue;
+            const kind = declarationKind(child.type);
+            if (kind) {
+                const name = getDeclarationName(child);
+                symbols.push({
+                    name: name || 'default',
+                    kind,
+                    exported: true,
+                    line: child.startPosition.row + 1,
+                });
+                if (kind === 'class') {
+                    extractClassMembers(child, symbols);
+                }
+            }
+        }
+    }
+}
+function extractClassMembers(classNode, symbols) {
+    const body = classNode.childForFieldName('body');
+    if (!body)
+        return;
+    for (const member of body.namedChildren) {
+        if (member.type === 'method_definition' || member.type === 'public_field_definition') {
+            const nameNode = member.childForFieldName('name');
+            if (nameNode) {
+                symbols.push({
+                    name: nameNode.text,
+                    kind: 'method',
+                    exported: true,
+                    line: member.startPosition.row + 1,
+                });
+            }
+        }
+    }
+}
+function extractTSDependencies(root) {
+    const deps = [];
+    for (let i = 0; i < root.childCount; i++) {
+        const node = root.child(i);
+        if (!node)
+            continue;
+        if (node.type === 'import_statement') {
+            const dep = extractImportDependency(node);
+            if (dep)
+                deps.push(dep);
+        }
+        // Also handle export ... from '...'
+        if (node.type === 'export_statement') {
+            const source = findSourceString(node);
+            if (source) {
+                const names = extractExportNames(node);
+                deps.push({
+                    source,
+                    names,
+                    isRelative: source.startsWith('.'),
+                });
+            }
+        }
+    }
+    return deps;
+}
+function extractImportDependency(importNode) {
+    const sourceNode = importNode.childForFieldName('source');
+    if (!sourceNode) {
+        // Side-effect import: import './init' — source is a direct string child
+        for (let i = 0; i < importNode.childCount; i++) {
+            const child = importNode.child(i);
+            if (child?.type === 'string') {
+                const source = stripQuotes(child.text);
+                return { source, names: [], isRelative: source.startsWith('.') };
+            }
+        }
+        return null;
+    }
+    const source = stripQuotes(sourceNode.text);
+    const names = [];
+    // Find the import_clause
+    for (let i = 0; i < importNode.childCount; i++) {
+        const child = importNode.child(i);
+        if (child?.type === 'import_clause') {
+            extractImportClauseNames(child, names);
+        }
+    }
+    return { source, names, isRelative: source.startsWith('.') };
+}
+function extractImportClauseNames(clause, names) {
+    for (let i = 0; i < clause.childCount; i++) {
+        const child = clause.child(i);
+        if (!child)
+            continue;
+        if (child.type === 'identifier') {
+            // Default import
+            names.push(child.text);
+        }
+        else if (child.type === 'named_imports') {
+            for (const specifier of child.namedChildren) {
+                if (specifier.type === 'import_specifier') {
+                    const nameNode = specifier.childForFieldName('name');
+                    if (nameNode)
+                        names.push(nameNode.text);
+                }
+            }
+        }
+        else if (child.type === 'namespace_import') {
+            // import * as NS
+            const nameNode = child.childForFieldName('name') ?? child.namedChildren.find(c => c.type === 'identifier');
+            if (nameNode)
+                names.push(`* as ${nameNode.text}`);
+        }
+    }
+}
+function extractExportNames(exportNode) {
+    const names = [];
+    for (let i = 0; i < exportNode.childCount; i++) {
+        const child = exportNode.child(i);
+        if (child?.type === 'export_clause') {
+            for (const specifier of child.namedChildren) {
+                if (specifier.type === 'export_specifier') {
+                    const nameNode = specifier.childForFieldName('name');
+                    if (nameNode)
+                        names.push(nameNode.text);
+                }
+            }
+        }
+    }
+    return names;
+}
+function findSourceString(node) {
+    for (let i = 0; i < node.childCount; i++) {
+        const child = node.child(i);
+        if (child?.type === 'string' || child?.type === 'string_fragment') {
+            return stripQuotes(child.text);
+        }
+    }
+    // Check if the 'source' field exists
+    const source = node.childForFieldName('source');
+    if (source)
+        return stripQuotes(source.text);
+    return null;
+}
+// =============================================================================
+// PYTHON EXTRACTION
+// =============================================================================
+function extractPythonSymbols(root) {
+    const symbols = [];
+    for (let i = 0; i < root.childCount; i++) {
+        const node = root.child(i);
+        if (!node)
+            continue;
+        if (node.type === 'function_definition') {
+            const name = node.childForFieldName('name');
+            if (name) {
+                symbols.push({
+                    name: name.text,
+                    kind: 'function',
+                    exported: !name.text.startsWith('_'),
+                    line: node.startPosition.row + 1,
+                });
+            }
+        }
+        else if (node.type === 'class_definition') {
+            const name = node.childForFieldName('name');
+            if (name) {
+                symbols.push({
+                    name: name.text,
+                    kind: 'class',
+                    exported: !name.text.startsWith('_'),
+                    line: node.startPosition.row + 1,
+                });
+            }
+        }
+    }
+    return symbols;
+}
+function extractPythonDependencies(root) {
+    const deps = [];
+    for (let i = 0; i < root.childCount; i++) {
+        const node = root.child(i);
+        if (!node)
+            continue;
+        if (node.type === 'import_statement') {
+            // import module
+            for (const child of node.namedChildren) {
+                if (child.type === 'dotted_name') {
+                    deps.push({
+                        source: child.text,
+                        names: [child.text],
+                        isRelative: false,
+                    });
+                }
+                else if (child.type === 'aliased_import') {
+                    const nameNode = child.childForFieldName('name');
+                    if (nameNode) {
+                        deps.push({
+                            source: nameNode.text,
+                            names: [nameNode.text],
+                            isRelative: false,
+                        });
+                    }
+                }
+            }
+        }
+        else if (node.type === 'import_from_statement') {
+            // from module import name
+            let source = '';
+            let isRelative = false;
+            const names = [];
+            for (let j = 0; j < node.childCount; j++) {
+                const child = node.child(j);
+                if (!child)
+                    continue;
+                if (child.type === 'dotted_name' && source === '') {
+                    source = child.text;
+                }
+                else if (child.type === 'relative_import') {
+                    source = child.text;
+                    isRelative = true;
+                }
+                else if (child.type === 'dotted_name' && source !== '') {
+                    names.push(child.text);
+                }
+                else if (child.type === 'aliased_import') {
+                    const nameNode = child.childForFieldName('name');
+                    if (nameNode)
+                        names.push(nameNode.text);
+                }
+            }
+            if (source) {
+                deps.push({ source, names, isRelative });
+            }
+        }
+    }
+    return deps;
+}
+// =============================================================================
+// HELPERS
+// =============================================================================
+function declarationKind(nodeType) {
+    switch (nodeType) {
+        case 'function_declaration': return 'function';
+        case 'class_declaration': return 'class';
+        case 'interface_declaration': return 'interface';
+        case 'type_alias_declaration': return 'type';
+        case 'enum_declaration': return 'enum';
+        default: return null;
+    }
+}
+function getDeclarationName(node) {
+    const nameNode = node.childForFieldName('name');
+    return nameNode?.text ?? null;
+}
+function stripQuotes(str) {
+    if ((str.startsWith("'") && str.endsWith("'")) ||
+        (str.startsWith('"') && str.endsWith('"'))) {
+        return str.slice(1, -1);
+    }
+    return str;
+}
+export const LANGUAGE_PROFILES = [
+    {
+        extensions: ['.go'],
+        grammar: 'tree-sitter-go',
+        symbolNodes: {
+            'function_declaration': 'function',
+            'method_declaration': 'method',
+            'type_declaration': 'class',
+        },
+        importNodes: ['import_declaration'],
+        exportDetection: 'convention',
+        extractImport: (node) => {
+            // Go: import "pkg" or import ( "pkg1"; "pkg2" )
+            const deps = [];
+            const walkImport = (n) => {
+                if (n.type === 'import_spec' || n.type === 'interpreted_string_literal') {
+                    const source = stripQuotes(n.text);
+                    if (source && !source.startsWith('(')) {
+                        deps.push({ source, names: [path.basename(source)], isRelative: source.startsWith('.') });
+                    }
+                }
+                for (const child of n.namedChildren)
+                    walkImport(child);
+            };
+            walkImport(node);
+            return deps;
+        },
+    },
+    {
+        extensions: ['.rs'],
+        grammar: 'tree-sitter-rust',
+        symbolNodes: {
+            'function_item': 'function',
+            'impl_item': 'class',
+            'struct_item': 'class',
+            'enum_item': 'enum',
+            'trait_item': 'interface',
+            'type_item': 'type',
+        },
+        importNodes: ['use_declaration'],
+        exportDetection: 'keyword',
+        extractImport: (node) => {
+            const text = node.text;
+            const match = /use\s+(.+?)(?:\s+as\s+\w+)?;/.exec(text);
+            if (match) {
+                const source = match[1].replace(/::/g, '/');
+                return [{ source, names: [path.basename(source)], isRelative: source.startsWith('self') || source.startsWith('super') }];
+            }
+            return [];
+        },
+    },
+    {
+        extensions: ['.java'],
+        grammar: 'tree-sitter-java',
+        symbolNodes: {
+            'class_declaration': 'class',
+            'interface_declaration': 'interface',
+            'method_declaration': 'method',
+            'enum_declaration': 'enum',
+        },
+        importNodes: ['import_declaration'],
+        exportDetection: 'visibility',
+        extractImport: (node) => {
+            const text = node.text;
+            const match = /import\s+(?:static\s+)?(.+?);/.exec(text);
+            if (match) {
+                const source = match[1];
+                const parts = source.split('.');
+                return [{ source, names: [parts[parts.length - 1]], isRelative: false }];
+            }
+            return [];
+        },
+    },
+    {
+        extensions: ['.c', '.h'],
+        grammar: 'tree-sitter-c',
+        symbolNodes: {
+            'function_definition': 'function',
+            'struct_specifier': 'class',
+            'enum_specifier': 'enum',
+            'type_definition': 'type',
+        },
+        importNodes: ['preproc_include'],
+        exportDetection: 'convention',
+        extractImport: (node) => {
+            const text = node.text;
+            const match = /#include\s+[<"](.+?)[>"]/.exec(text);
+            if (match) {
+                const source = match[1];
+                return [{ source, names: [path.basename(source)], isRelative: source.includes('/') || text.includes('"') }];
+            }
+            return [];
+        },
+    },
+    {
+        extensions: ['.cpp', '.cc', '.cxx', '.hpp'],
+        grammar: 'tree-sitter-cpp',
+        symbolNodes: {
+            'function_definition': 'function',
+            'class_specifier': 'class',
+            'struct_specifier': 'class',
+            'enum_specifier': 'enum',
+            'namespace_definition': 'variable',
+        },
+        importNodes: ['preproc_include'],
+        exportDetection: 'convention',
+        extractImport: (node) => {
+            const text = node.text;
+            const match = /#include\s+[<"](.+?)[>"]/.exec(text);
+            if (match) {
+                const source = match[1];
+                return [{ source, names: [path.basename(source)], isRelative: source.includes('/') || text.includes('"') }];
+            }
+            return [];
+        },
+    },
+    {
+        extensions: ['.rb'],
+        grammar: 'tree-sitter-ruby',
+        symbolNodes: {
+            'method': 'function',
+            'singleton_method': 'function',
+            'class': 'class',
+            'module': 'class',
+        },
+        importNodes: ['call'],
+        exportDetection: 'convention',
+        extractImport: (node) => {
+            const text = node.text;
+            const match = /(?:require|require_relative)\s+['"](.+?)['"]/.exec(text);
+            if (match) {
+                const source = match[1];
+                return [{ source, names: [path.basename(source)], isRelative: text.includes('require_relative') }];
+            }
+            return [];
+        },
+    },
+    {
+        extensions: ['.sh', '.bash'],
+        grammar: 'tree-sitter-bash',
+        symbolNodes: {
+            'function_definition': 'function',
+        },
+        importNodes: ['command'],
+        exportDetection: 'convention',
+        extractImport: (node) => {
+            const text = node.text;
+            const match = /(?:source|\.)\s+['"]?(.+?)['"]?(?:\s|$)/.exec(text);
+            if (match) {
+                const source = match[1];
+                return [{ source, names: [path.basename(source)], isRelative: source.startsWith('.') || source.startsWith('/') }];
+            }
+            return [];
+        },
+    },
+];
+// =============================================================================
+// POLYGLOT: GENERIC EXTRACTORS
+// =============================================================================
+function initPolyglotParser(ext, profile) {
+    try {
+        // eslint-disable-next-line @typescript-eslint/no-require-imports
+        const Parser = require('tree-sitter');
+        // eslint-disable-next-line @typescript-eslint/no-require-imports
+        const lang = require(profile.grammar);
+        const parser = new Parser();
+        parser.setLanguage(lang.default ?? lang);
+        parsers.set(ext, parser);
+        return parser;
+    }
+    catch {
+        parserInitFailed.add(ext);
+        return null;
+    }
+}
+function extractSymbolsGeneric(root, profile) {
+    const symbols = [];
+    walkTopLevel(root, (node) => {
+        const kind = profile.symbolNodes[node.type];
+        if (kind) {
+            const name = getDeclarationName(node);
+            if (name) {
+                const exported = detectExport(node, name, profile.exportDetection);
+                symbols.push({ name, kind, exported, line: node.startPosition.row + 1 });
+            }
+        }
+    });
+    return symbols;
+}
+function extractDependenciesGeneric(root, profile) {
+    const deps = [];
+    walkTopLevel(root, (node) => {
+        if (profile.importNodes.includes(node.type)) {
+            deps.push(...profile.extractImport(node));
+        }
+    });
+    return deps;
+}
+function walkTopLevel(root, callback) {
+    for (let i = 0; i < root.childCount; i++) {
+        const node = root.child(i);
+        if (node)
+            callback(node);
+    }
+}
+function detectExport(node, name, detection) {
+    switch (detection) {
+        case 'convention':
+            // Go: uppercase first letter = exported; C/C++/Ruby/Bash: treat all as exported
+            return name.length > 0 && name[0] === name[0].toUpperCase() && name[0] !== name[0].toLowerCase();
+        case 'keyword': {
+            // Rust: check for 'pub' keyword
+            const nodeText = node.text;
+            return nodeText.startsWith('pub ') || nodeText.startsWith('pub(');
+        }
+        case 'visibility': {
+            // Java: check for 'public' modifier
+            const nodeText = node.text;
+            return nodeText.includes('public ');
+        }
+        default:
+            return true;
+    }
+}
+//# sourceMappingURL=codebase-ast.js.map