codedev-mcp 3.2.0

package/dist/analyzers/symbols.d.ts

@@ -0,0 +1,49 @@
+/**
+ * Symbol Extraction & Code Analysis
+ * Language-agnostic symbol detection for 40+ languages
+ */
+export interface Symbol {
+    name: string;
+    kind: 'function' | 'class' | 'interface' | 'type' | 'constant' | 'export';
+    line: number;
+    language: string;
+    signature?: string;
+}
+export interface FileAnalysis {
+    path: string;
+    language: string;
+    size: number;
+    lines: number;
+    codeLines: number;
+    commentLines: number;
+    blankLines: number;
+    symbols: Symbol[];
+    imports: string[];
+    /** Rough cyclomatic complexity estimate */
+    complexity: number;
+}
+/**
+ * Extract all symbols from a file.
+ * @param filePath - Path to the source file
+ * @returns Array of symbols found in the file
+ */
+export declare function extractSymbols(filePath: string): Promise<Symbol[]>;
+/**
+ * Extract imports from a file.
+ * @param filePath - Path to the source file
+ * @returns Array of imported module names
+ */
+export declare function extractImports(filePath: string): Promise<string[]>;
+/**
+ * Full file analysis.
+ * @param filePath - Path to the source file
+ * @returns Complete file analysis with symbols, imports, and metrics
+ */
+export declare function analyzeFile(filePath: string): Promise<FileAnalysis>;
+/**
+ * Generate a concise outline of a file's structure.
+ * @param analysis - The file analysis result
+ * @returns Formatted string outline of the file
+ */
+export declare function formatFileOutline(analysis: FileAnalysis): string;
+//# sourceMappingURL=symbols.d.ts.map

package/dist/analyzers/symbols.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"symbols.d.ts","sourceRoot":"","sources":["../../src/analyzers/symbols.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAKH,MAAM,WAAW,MAAM;IACrB,IAAI,EAAE,MAAM,CAAC;IACb,IAAI,EAAE,UAAU,GAAG,OAAO,GAAG,WAAW,GAAG,MAAM,GAAG,UAAU,GAAG,QAAQ,CAAC;IAC1E,IAAI,EAAE,MAAM,CAAC;IACb,QAAQ,EAAE,MAAM,CAAC;IACjB,SAAS,CAAC,EAAE,MAAM,CAAC;CACpB;AAED,MAAM,WAAW,YAAY;IAC3B,IAAI,EAAE,MAAM,CAAC;IACb,QAAQ,EAAE,MAAM,CAAC;IACjB,IAAI,EAAE,MAAM,CAAC;IACb,KAAK,EAAE,MAAM,CAAC;IACd,SAAS,EAAE,MAAM,CAAC;IAClB,YAAY,EAAE,MAAM,CAAC;IACrB,UAAU,EAAE,MAAM,CAAC;IACnB,OAAO,EAAE,MAAM,EAAE,CAAC;IAClB,OAAO,EAAE,MAAM,EAAE,CAAC;IAClB,2CAA2C;IAC3C,UAAU,EAAE,MAAM,CAAC;CACpB;AAED;;;;GAIG;AACH,wBAAsB,cAAc,CAAC,QAAQ,EAAE,MAAM,GAAG,OAAO,CAAC,MAAM,EAAE,CAAC,CAiDxE;AAED;;;;GAIG;AACH,wBAAsB,cAAc,CAAC,QAAQ,EAAE,MAAM,GAAG,OAAO,CAAC,MAAM,EAAE,CAAC,CAexE;AAyFD;;;;GAIG;AACH,wBAAsB,WAAW,CAAC,QAAQ,EAAE,MAAM,GAAG,OAAO,CAAC,YAAY,CAAC,CAsBzE;AAED;;;;GAIG;AACH,wBAAgB,iBAAiB,CAAC,QAAQ,EAAE,YAAY,GAAG,MAAM,CAgChE"}

package/dist/analyzers/symbols.js

@@ -0,0 +1,212 @@
+/**
+ * Symbol Extraction & Code Analysis
+ * Language-agnostic symbol detection for 40+ languages
+ */
+import { readFile, stat } from 'node:fs/promises';
+import { detectLanguage, getSymbolPatterns, getImportPatterns, getCommentStyle } from '../utils/languages.js';
+/**
+ * Extract all symbols from a file.
+ * @param filePath - Path to the source file
+ * @returns Array of symbols found in the file
+ */
+export async function extractSymbols(filePath) {
+    const content = await readFile(filePath, 'utf-8');
+    const language = detectLanguage(filePath);
+    const patterns = getSymbolPatterns(language);
+    const symbols = [];
+    const lines = content.split('\n');
+    const kinds = [
+        { key: 'functions', kind: 'function' },
+        { key: 'classes', kind: 'class' },
+        { key: 'interfaces', kind: 'interface' },
+        { key: 'types', kind: 'type' },
+        { key: 'constants', kind: 'constant' },
+        { key: 'exports', kind: 'export' },
+    ];
+    for (const { key, kind } of kinds) {
+        for (const pattern of patterns[key]) {
+            // Reset regex state
+            const regex = new RegExp(pattern.source, pattern.flags);
+            let match;
+            while ((match = regex.exec(content)) !== null) {
+                const name = match[1];
+                if (!name || name.length < 2)
+                    continue;
+                // Deduplicate
+                if (symbols.some((s) => s.name === name && s.kind === kind))
+                    continue;
+                // Find line number
+                const beforeMatch = content.slice(0, match.index);
+                const line = beforeMatch.split('\n').length;
+                // Get signature (the full matched line)
+                const lineContent = lines[line - 1]?.trim() || '';
+                symbols.push({
+                    name,
+                    kind,
+                    line,
+                    language,
+                    // Truncate long lines
+                    signature: lineContent.slice(0, 200),
+                });
+            }
+        }
+    }
+    // Sort by line number
+    symbols.sort((a, b) => a.line - b.line);
+    return symbols;
+}
+/**
+ * Extract imports from a file.
+ * @param filePath - Path to the source file
+ * @returns Array of imported module names
+ */
+export async function extractImports(filePath) {
+    const content = await readFile(filePath, 'utf-8');
+    const language = detectLanguage(filePath);
+    const patterns = getImportPatterns(language);
+    const imports = new Set();
+    for (const pattern of patterns) {
+        const regex = new RegExp(pattern.source, pattern.flags);
+        let match;
+        while ((match = regex.exec(content)) !== null) {
+            if (match[1])
+                imports.add(match[1]);
+        }
+    }
+    return [...imports];
+}
+/**
+ * Count code, comment, and blank lines.
+ * @param content - The file content
+ * @param language - The programming language
+ * @returns Line counts by type
+ */
+function countLineTypes(content, language) {
+    const lines = content.split('\n');
+    const style = getCommentStyle(language);
+    let code = 0, comment = 0, blank = 0;
+    let inMultiLineComment = false;
+    for (const line of lines) {
+        const trimmed = line.trim();
+        if (trimmed === '') {
+            blank++;
+            continue;
+        }
+        if (inMultiLineComment) {
+            comment++;
+            if (style.multiEnd && trimmed.includes(style.multiEnd)) {
+                inMultiLineComment = false;
+            }
+            continue;
+        }
+        if (style.multiStart && trimmed.startsWith(style.multiStart)) {
+            comment++;
+            if (!style.multiEnd || !trimmed.includes(style.multiEnd, style.multiStart.length)) {
+                inMultiLineComment = true;
+            }
+            continue;
+        }
+        if (style.single && trimmed.startsWith(style.single)) {
+            comment++;
+            continue;
+        }
+        code++;
+    }
+    return { code, comment, blank };
+}
+/**
+ * Rough cyclomatic complexity estimate.
+ * @param content - The file content
+ * @returns Estimated cyclomatic complexity score
+ */
+function estimateComplexity(content) {
+    // Count decision points
+    const decisionKeywords = [
+        /\bif\b/g,
+        /\belse\s+if\b/g,
+        /\belif\b/g,
+        /\bfor\b/g,
+        /\bwhile\b/g,
+        /\bdo\b/g,
+        /\bswitch\b/g,
+        /\bcase\b/g,
+        /\bmatch\b/g,
+        /\bcatch\b/g,
+        /\bexcept\b/g,
+        /\brescue\b/g,
+        /\?\?/g,
+        /\?\./g,
+        /&&/g,
+        /\|\|/g,
+        /\bwhen\b/g,
+        /\bguard\b/g,
+    ];
+    // Base complexity
+    let complexity = 1;
+    for (const pattern of decisionKeywords) {
+        const matches = content.match(pattern);
+        if (matches)
+            complexity += matches.length;
+    }
+    return complexity;
+}
+/**
+ * Full file analysis.
+ * @param filePath - Path to the source file
+ * @returns Complete file analysis with symbols, imports, and metrics
+ */
+export async function analyzeFile(filePath) {
+    const content = await readFile(filePath, 'utf-8');
+    const fileStat = await stat(filePath);
+    const language = detectLanguage(filePath);
+    const lines = content.split('\n').length;
+    const lineCounts = countLineTypes(content, language);
+    const symbols = await extractSymbols(filePath);
+    const imports = await extractImports(filePath);
+    const complexity = estimateComplexity(content);
+    return {
+        path: filePath,
+        language,
+        size: fileStat.size,
+        lines,
+        codeLines: lineCounts.code,
+        commentLines: lineCounts.comment,
+        blankLines: lineCounts.blank,
+        symbols,
+        imports,
+        complexity,
+    };
+}
+/**
+ * Generate a concise outline of a file's structure.
+ * @param analysis - The file analysis result
+ * @returns Formatted string outline of the file
+ */
+export function formatFileOutline(analysis) {
+    const parts = [];
+    parts.push(`📄 ${analysis.path}`);
+    parts.push(`   Language: ${analysis.language} | Lines: ${analysis.lines} (code: ${analysis.codeLines}, comments: ${analysis.commentLines}) | Complexity: ${analysis.complexity}`);
+    if (analysis.imports.length > 0) {
+        parts.push(`   📦 Imports: ${analysis.imports.join(', ')}`);
+    }
+    const grouped = {};
+    for (const sym of analysis.symbols) {
+        if (!grouped[sym.kind])
+            grouped[sym.kind] = [];
+        grouped[sym.kind].push(sym);
+    }
+    const icons = {
+        class: '🏗️',
+        interface: '📋',
+        type: '🔷',
+        function: 'ƒ',
+        constant: '🔒',
+        export: '📤',
+    };
+    for (const [kind, syms] of Object.entries(grouped)) {
+        const icon = icons[kind] || '•';
+        parts.push(`   ${icon} ${kind}s: ${syms.map((s) => `${s.name}:${s.line}`).join(', ')}`);
+    }
+    return parts.join('\n');
+}
+//# sourceMappingURL=symbols.js.map

package/dist/analyzers/symbols.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"symbols.js","sourceRoot":"","sources":["../../src/analyzers/symbols.ts"],"names":[],"mappings":"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"}

package/dist/analyzers/tree-sitter.d.ts

@@ -0,0 +1,71 @@
+/**
+ * Tree-sitter AST parsing for accurate code analysis.
+ * Uses web-tree-sitter (WASM-based, no native compilation).
+ * Falls back to regex-based parsing if grammars unavailable.
+ *
+ * Supported languages: TypeScript, JavaScript, Python, Go, Java, Rust, C/C++
+ */
+export interface ASTSymbol {
+    name: string;
+    type: 'function' | 'class' | 'method' | 'interface' | 'enum' | 'variable' | 'type' | 'module' | 'struct' | 'trait';
+    startLine: number;
+    endLine: number;
+    exported: boolean;
+    params?: string[];
+    returnType?: string;
+    docComment?: string;
+    /** Methods inside classes, etc. */
+    children?: ASTSymbol[];
+}
+export interface CallGraphEntry {
+    caller: string;
+    callee: string;
+    file: string;
+    line: number;
+}
+export interface ScopeInfo {
+    name: string;
+    type: string;
+    startLine: number;
+    endLine: number;
+    variables: string[];
+    children: ScopeInfo[];
+}
+/**
+ * Initialize tree-sitter. Call once at startup.
+ * @returns True if initialization succeeded
+ */
+export declare function initTreeSitter(): Promise<boolean>;
+/**
+ * Check if tree-sitter is available and ready.
+ * @returns True if tree-sitter has been initialized
+ */
+export declare function isTreeSitterReady(): boolean;
+/**
+ * Get supported languages for tree-sitter.
+ * @returns Array of supported language names
+ */
+export declare function getTreeSitterLanguages(): string[];
+/**
+ * Parse a file into an AST and extract symbols.
+ * Falls back to null if tree-sitter isn't available for this language.
+ * @param filePath - Path to the source file
+ * @param language - The programming language
+ * @returns Array of AST symbols or null if parsing unavailable
+ */
+export declare function parseAST(filePath: string, language: string): Promise<ASTSymbol[] | null>;
+/**
+ * Extract call graph from a file -- which functions call which.
+ * @param filePath - Path to the source file
+ * @param language - The programming language
+ * @returns Array of call graph entries or null if parsing unavailable
+ */
+export declare function extractCallGraph(filePath: string, language: string): Promise<CallGraphEntry[] | null>;
+/**
+ * Extract scope information from a file.
+ * @param filePath - Path to the source file
+ * @param language - The programming language
+ * @returns Array of scope information or null if parsing unavailable
+ */
+export declare function extractScopes(filePath: string, language: string): Promise<ScopeInfo[] | null>;
+//# sourceMappingURL=tree-sitter.d.ts.map

package/dist/analyzers/tree-sitter.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"tree-sitter.d.ts","sourceRoot":"","sources":["../../src/analyzers/tree-sitter.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AA6CH,MAAM,WAAW,SAAS;IACxB,IAAI,EAAE,MAAM,CAAC;IACb,IAAI,EAAE,UAAU,GAAG,OAAO,GAAG,QAAQ,GAAG,WAAW,GAAG,MAAM,GAAG,UAAU,GAAG,MAAM,GAAG,QAAQ,GAAG,QAAQ,GAAG,OAAO,CAAC;IACnH,SAAS,EAAE,MAAM,CAAC;IAClB,OAAO,EAAE,MAAM,CAAC;IAChB,QAAQ,EAAE,OAAO,CAAC;IAClB,MAAM,CAAC,EAAE,MAAM,EAAE,CAAC;IAClB,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB,mCAAmC;IACnC,QAAQ,CAAC,EAAE,SAAS,EAAE,CAAC;CACxB;AAED,MAAM,WAAW,cAAc;IAC7B,MAAM,EAAE,MAAM,CAAC;IACf,MAAM,EAAE,MAAM,CAAC;IACf,IAAI,EAAE,MAAM,CAAC;IACb,IAAI,EAAE,MAAM,CAAC;CACd;AAED,MAAM,WAAW,SAAS;IACxB,IAAI,EAAE,MAAM,CAAC;IACb,IAAI,EAAE,MAAM,CAAC;IACb,SAAS,EAAE,MAAM,CAAC;IAClB,OAAO,EAAE,MAAM,CAAC;IAChB,SAAS,EAAE,MAAM,EAAE,CAAC;IACpB,QAAQ,EAAE,SAAS,EAAE,CAAC;CACvB;AAED;;;GAGG;AACH,wBAAsB,cAAc,IAAI,OAAO,CAAC,OAAO,CAAC,CAavD;AAED;;;GAGG;AACH,wBAAgB,iBAAiB,IAAI,OAAO,CAE3C;AAED;;;GAGG;AACH,wBAAgB,sBAAsB,IAAI,MAAM,EAAE,CAEjD;AAsCD;;;;;;GAMG;AACH,wBAAsB,QAAQ,CAAC,QAAQ,EAAE,MAAM,EAAE,QAAQ,EAAE,MAAM,GAAG,OAAO,CAAC,SAAS,EAAE,GAAG,IAAI,CAAC,CAoB9F;AA4GD;;;;;GAKG;AACH,wBAAsB,gBAAgB,CAAC,QAAQ,EAAE,MAAM,EAAE,QAAQ,EAAE,MAAM,GAAG,OAAO,CAAC,cAAc,EAAE,GAAG,IAAI,CAAC,CAwD3G;AAED;;;;;GAKG;AACH,wBAAsB,aAAa,CAAC,QAAQ,EAAE,MAAM,EAAE,QAAQ,EAAE,MAAM,GAAG,OAAO,CAAC,SAAS,EAAE,GAAG,IAAI,CAAC,CAmEnG"}

package/dist/analyzers/tree-sitter.js

@@ -0,0 +1,333 @@
+/**
+ * Tree-sitter AST parsing for accurate code analysis.
+ * Uses web-tree-sitter (WASM-based, no native compilation).
+ * Falls back to regex-based parsing if grammars unavailable.
+ *
+ * Supported languages: TypeScript, JavaScript, Python, Go, Java, Rust, C/C++
+ */
+import path from 'node:path';
+import { readFile } from 'node:fs/promises';
+// Dynamic import for web-tree-sitter (may not be available)
+let Parser = null;
+let treeSitterReady = false;
+const loadedLanguages = new Map();
+// Grammar file locations (downloaded on first use)
+const GRAMMAR_URLS = {
+    typescript: 'tree-sitter-typescript.wasm',
+    javascript: 'tree-sitter-javascript.wasm',
+    python: 'tree-sitter-python.wasm',
+    go: 'tree-sitter-go.wasm',
+    java: 'tree-sitter-java.wasm',
+    rust: 'tree-sitter-rust.wasm',
+    c: 'tree-sitter-c.wasm',
+    cpp: 'tree-sitter-cpp.wasm',
+};
+/**
+ * Initialize tree-sitter. Call once at startup.
+ * @returns True if initialization succeeded
+ */
+export async function initTreeSitter() {
+    try {
+        const TreeSitter = await import('web-tree-sitter');
+        const TreeSitterModule = TreeSitter.default || TreeSitter;
+        // Type assertion needed because web-tree-sitter types don't match our interface exactly
+        Parser = TreeSitterModule;
+        await Parser.init();
+        treeSitterReady = true;
+        return true;
+    }
+    catch {
+        treeSitterReady = false;
+        return false;
+    }
+}
+/**
+ * Check if tree-sitter is available and ready.
+ * @returns True if tree-sitter has been initialized
+ */
+export function isTreeSitterReady() {
+    return treeSitterReady;
+}
+/**
+ * Get supported languages for tree-sitter.
+ * @returns Array of supported language names
+ */
+export function getTreeSitterLanguages() {
+    return Object.keys(GRAMMAR_URLS);
+}
+/**
+ * Load a language grammar. Returns null if not available.
+ * @param language - The language name to load
+ * @returns The loaded language grammar or null
+ */
+async function loadLanguage(language) {
+    if (!treeSitterReady || !Parser)
+        return null;
+    if (loadedLanguages.has(language))
+        return loadedLanguages.get(language);
+    const grammarFile = GRAMMAR_URLS[language];
+    if (!grammarFile)
+        return null;
+    try {
+        // Try loading from node_modules or local cache
+        const possiblePaths = [
+            path.join(process.cwd(), 'grammars', grammarFile),
+            path.join(process.cwd(), '.codedev-mcp', 'grammars', grammarFile),
+            path.join(process.env.HOME || '', '.codedev-mcp', 'grammars', grammarFile),
+        ];
+        for (const p of possiblePaths) {
+            try {
+                const lang = await Parser.Language.load(p);
+                loadedLanguages.set(language, lang);
+                return lang;
+            }
+            catch {
+                continue;
+            }
+        }
+        return null;
+    }
+    catch {
+        return null;
+    }
+}
+/**
+ * Parse a file into an AST and extract symbols.
+ * Falls back to null if tree-sitter isn't available for this language.
+ * @param filePath - Path to the source file
+ * @param language - The programming language
+ * @returns Array of AST symbols or null if parsing unavailable
+ */
+export async function parseAST(filePath, language) {
+    const lang = await loadLanguage(language);
+    if (!lang || !Parser)
+        return null;
+    try {
+        const content = await readFile(filePath, 'utf-8');
+        const parser = new Parser();
+        parser.setLanguage(lang);
+        const tree = parser.parse(content);
+        const symbols = [];
+        extractSymbolsFromNode(tree.rootNode, symbols, content, language);
+        parser.delete();
+        tree.delete();
+        return symbols;
+    }
+    catch {
+        return null;
+    }
+}
+/**
+ * Recursively extract symbols from AST nodes.
+ * @param node - The current AST node
+ * @param symbols - Accumulator for found symbols
+ * @param source - The full source code
+ * @param language - The programming language
+ * @param depth - Current recursion depth
+ */
+function extractSymbolsFromNode(node, symbols, source, language, depth = 0) {
+    // Prevent infinite recursion
+    if (depth > 10)
+        return;
+    const symbolTypes = {
+        function_declaration: 'function',
+        function_definition: 'function',
+        method_definition: 'method',
+        method_declaration: 'method',
+        class_declaration: 'class',
+        class_definition: 'class',
+        interface_declaration: 'interface',
+        type_alias_declaration: 'type',
+        enum_declaration: 'enum',
+        struct_item: 'struct',
+        impl_item: 'module',
+        trait_item: 'trait',
+        variable_declaration: 'variable',
+        lexical_declaration: 'variable',
+    };
+    const nodeType = symbolTypes[node.type];
+    if (nodeType) {
+        const nameNode = node.childForFieldName?.('name') ||
+            node.children?.find((c) => c.type === 'identifier' || c.type === 'type_identifier');
+        if (nameNode) {
+            const symbol = {
+                name: nameNode.text,
+                type: nodeType,
+                startLine: node.startPosition.row + 1,
+                endLine: node.endPosition.row + 1,
+                exported: isExported(node, source),
+                children: [],
+            };
+            // Extract params for functions
+            const params = node.childForFieldName?.('parameters') || node.childForFieldName?.('formal_parameters');
+            if (params) {
+                symbol.params = extractParams(params);
+            }
+            // Extract return type
+            const returnType = node.childForFieldName?.('return_type') || node.childForFieldName?.('result');
+            if (returnType) {
+                symbol.returnType = returnType.text;
+            }
+            // Extract doc comment (preceding comment node)
+            const prevSibling = node.previousNamedSibling;
+            if (prevSibling && (prevSibling.type === 'comment' || prevSibling.type === 'block_comment')) {
+                symbol.docComment = prevSibling.text;
+            }
+            // Extract children (methods inside classes)
+            if (nodeType === 'class' || nodeType === 'struct' || nodeType === 'trait') {
+                const body = node.childForFieldName?.('body');
+                if (body) {
+                    const childSymbols = [];
+                    for (const child of body.children || []) {
+                        extractSymbolsFromNode(child, childSymbols, source, language, depth + 1);
+                    }
+                    symbol.children = childSymbols;
+                }
+            }
+            symbols.push(symbol);
+            // Don't recurse into the same symbol
+            return;
+        }
+    }
+    // Recurse into children
+    for (const child of node.children || []) {
+        extractSymbolsFromNode(child, symbols, source, language, depth + 1);
+    }
+}
+function isExported(node, source) {
+    const lineStart = source.lastIndexOf('\n', node.startIndex) + 1;
+    const lineText = source.slice(lineStart, node.startIndex + 50);
+    return /export\s/.test(lineText) || /^pub\s/.test(lineText);
+}
+function extractParams(paramsNode) {
+    return (paramsNode.children || [])
+        .filter((c) => c.type !== '(' && c.type !== ')' && c.type !== ',')
+        .map((c) => c.text)
+        .filter((t) => t.trim().length > 0);
+}
+/**
+ * Extract call graph from a file -- which functions call which.
+ * @param filePath - Path to the source file
+ * @param language - The programming language
+ * @returns Array of call graph entries or null if parsing unavailable
+ */
+export async function extractCallGraph(filePath, language) {
+    const lang = await loadLanguage(language);
+    if (!lang || !Parser)
+        return null;
+    try {
+        const content = await readFile(filePath, 'utf-8');
+        const parser = new Parser();
+        parser.setLanguage(lang);
+        const tree = parser.parse(content);
+        const calls = [];
+        const funcStack = [];
+        function walkForCalls(node) {
+            // Track function scope
+            const isFuncDef = ['function_declaration', 'function_definition', 'method_definition', 'arrow_function'].includes(node.type);
+            if (isFuncDef) {
+                const nameNode = node.childForFieldName?.('name');
+                if (nameNode)
+                    funcStack.push(nameNode.text);
+            }
+            // Detect function calls
+            if (node.type === 'call_expression') {
+                const funcNode = node.childForFieldName?.('function') || node.children?.[0];
+                if (funcNode) {
+                    const callee = funcNode.text;
+                    const caller = funcStack.length > 0 ? funcStack[funcStack.length - 1] : '<module>';
+                    calls.push({
+                        caller,
+                        callee,
+                        file: filePath,
+                        line: node.startPosition.row + 1,
+                    });
+                }
+            }
+            for (const child of node.children || []) {
+                walkForCalls(child);
+            }
+            if (isFuncDef && node.childForFieldName?.('name')) {
+                funcStack.pop();
+            }
+        }
+        walkForCalls(tree.rootNode);
+        parser.delete();
+        tree.delete();
+        return calls;
+    }
+    catch {
+        return null;
+    }
+}
+/**
+ * Extract scope information from a file.
+ * @param filePath - Path to the source file
+ * @param language - The programming language
+ * @returns Array of scope information or null if parsing unavailable
+ */
+export async function extractScopes(filePath, language) {
+    const lang = await loadLanguage(language);
+    if (!lang || !Parser)
+        return null;
+    try {
+        const content = await readFile(filePath, 'utf-8');
+        const parser = new Parser();
+        parser.setLanguage(lang);
+        const tree = parser.parse(content);
+        const scopes = [];
+        function walkForScopes(node, parent) {
+            const scopeTypes = [
+                'function_declaration',
+                'function_definition',
+                'method_definition',
+                'class_declaration',
+                'class_definition',
+                'block',
+                'if_statement',
+                'for_statement',
+                'while_statement',
+                'try_statement',
+            ];
+            if (scopeTypes.includes(node.type)) {
+                const nameNode = node.childForFieldName?.('name');
+                const scope = {
+                    name: nameNode?.text || `<${node.type}>`,
+                    type: node.type,
+                    startLine: node.startPosition.row + 1,
+                    endLine: node.endPosition.row + 1,
+                    variables: [],
+                    children: [],
+                };
+                // Extract variable declarations within this scope
+                for (const child of node.children || []) {
+                    if (['variable_declaration', 'lexical_declaration', 'assignment'].includes(child.type)) {
+                        const varName = child.childForFieldName?.('name');
+                        if (varName)
+                            scope.variables.push(varName.text);
+                    }
+                }
+                if (parent)
+                    parent.children.push(scope);
+                else
+                    scopes.push(scope);
+                for (const child of node.children || []) {
+                    walkForScopes(child, scope);
+                }
+            }
+            else {
+                for (const child of node.children || []) {
+                    walkForScopes(child, parent);
+                }
+            }
+        }
+        walkForScopes(tree.rootNode, null);
+        parser.delete();
+        tree.delete();
+        return scopes;
+    }
+    catch {
+        return null;
+    }
+}
+//# sourceMappingURL=tree-sitter.js.map