anantham-v2 2.0.0-alpha.1 → 2.0.2

package/dist/code-intel/lsp-bridge.js

@@ -0,0 +1,103 @@
+/**
+ * LSP Client Bridge Integration
+ * PRD-CODE-004: LSP Client Bridge Integration
+ */
+export class LspClientBridge {
+    isInitialized = false;
+    mockHandler;
+    rootUri;
+    constructor(options = {}) {
+        this.mockHandler = options.mockHandler;
+        this.rootUri = options.rootUri ?? "file:///";
+    }
+    async initialize() {
+        if (this.mockHandler) {
+            await this.mockHandler("initialize", { rootUri: this.rootUri });
+        }
+        this.isInitialized = true;
+        return true;
+    }
+    async getDefinition(filePath, position) {
+        this.ensureInitialized();
+        if (this.mockHandler) {
+            const res = (await this.mockHandler("textDocument/definition", {
+                textDocument: { uri: `file://${filePath}` },
+                position: { line: position.line - 1, character: position.character - 1 },
+            }));
+            return res ?? [];
+        }
+        return [];
+    }
+    async getReferences(filePath, position) {
+        this.ensureInitialized();
+        if (this.mockHandler) {
+            const res = (await this.mockHandler("textDocument/references", {
+                textDocument: { uri: `file://${filePath}` },
+                position: { line: position.line - 1, character: position.character - 1 },
+                context: { includeDeclaration: true },
+            }));
+            return res ?? [];
+        }
+        return [];
+    }
+    async getHover(filePath, position) {
+        this.ensureInitialized();
+        if (this.mockHandler) {
+            const res = (await this.mockHandler("textDocument/hover", {
+                textDocument: { uri: `file://${filePath}` },
+                position: { line: position.line - 1, character: position.character - 1 },
+            }));
+            return res ?? null;
+        }
+        return null;
+    }
+    async getDocumentSymbols(filePath) {
+        this.ensureInitialized();
+        if (this.mockHandler) {
+            const res = (await this.mockHandler("textDocument/documentSymbol", {
+                textDocument: { uri: `file://${filePath}` },
+            }));
+            return res ?? [];
+        }
+        return [];
+    }
+    async getWorkspaceSymbols(query) {
+        this.ensureInitialized();
+        if (this.mockHandler) {
+            const res = (await this.mockHandler("workspace/symbol", { query }));
+            return res ?? [];
+        }
+        return [];
+    }
+    async rename(filePath, position, newName) {
+        this.ensureInitialized();
+        if (this.mockHandler) {
+            const res = (await this.mockHandler("textDocument/rename", {
+                textDocument: { uri: `file://${filePath}` },
+                position: { line: position.line - 1, character: position.character - 1 },
+                newName,
+            }));
+            return res ?? { changes: {} };
+        }
+        return { changes: {} };
+    }
+    async getDiagnostics(filePath) {
+        this.ensureInitialized();
+        if (this.mockHandler) {
+            const res = (await this.mockHandler("textDocument/diagnostics", {
+                textDocument: { uri: `file://${filePath}` },
+            }));
+            return res ?? [];
+        }
+        return [];
+    }
+    shutdown() {
+        this.isInitialized = false;
+    }
+    ensureInitialized() {
+        if (!this.isInitialized) {
+            throw new Error("LspClientBridge must be initialized before making requests.");
+        }
+    }
+}
+//# sourceMappingURL=lsp-bridge.js.map

package/dist/code-intel/lsp-bridge.js.map

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

package/dist/code-intel/parsers/multi-language-ast-parser.d.ts

@@ -0,0 +1,22 @@
+/**
+ * Multi-Language AST & Grammar Parser
+ * PRD-CODE-003: Multi-Language AST & Parser Adapters
+ * PRD-INV-001: Strict Code Intelligence Invariants & Fault Isolation
+ */
+import type { SupportedLanguage, ParseResult } from "../types.js";
+export declare class MultiLanguageAstParser {
+    detectLanguage(filePath: string): SupportedLanguage;
+    parse(filePath: string, content: string): ParseResult;
+    private isBinary;
+    private parseTypeScriptJavaScript;
+    private parsePython;
+    private parseGo;
+    private parseRust;
+    private parseJava;
+    private parseCAndCpp;
+    private parseJson;
+    private parseYaml;
+    private parseMarkdown;
+    private parseGeneric;
+}
+//# sourceMappingURL=multi-language-ast-parser.d.ts.map

package/dist/code-intel/parsers/multi-language-ast-parser.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"multi-language-ast-parser.d.ts","sourceRoot":"","sources":["../../../src/code-intel/parsers/multi-language-ast-parser.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAGH,OAAO,KAAK,EACV,iBAAiB,EACjB,WAAW,EAMZ,MAAM,aAAa,CAAC;AAErB,qBAAa,sBAAsB;IAC1B,cAAc,CAAC,QAAQ,EAAE,MAAM,GAAG,iBAAiB;IA0CnD,KAAK,CAAC,QAAQ,EAAE,MAAM,EAAE,OAAO,EAAE,MAAM,GAAG,WAAW;IAiG5D,OAAO,CAAC,QAAQ;IAUhB,OAAO,CAAC,yBAAyB;IAqIjC,OAAO,CAAC,WAAW;IAiEnB,OAAO,CAAC,OAAO;IAwDf,OAAO,CAAC,SAAS;IA+CjB,OAAO,CAAC,SAAS;IAkCjB,OAAO,CAAC,YAAY;IAmCpB,OAAO,CAAC,SAAS;IAyBjB,OAAO,CAAC,SAAS;IAiBjB,OAAO,CAAC,aAAa;IAkBrB,OAAO,CAAC,YAAY;CAgBrB"}

package/dist/code-intel/parsers/multi-language-ast-parser.js

@@ -0,0 +1,536 @@
+/**
+ * Multi-Language AST & Grammar Parser
+ * PRD-CODE-003: Multi-Language AST & Parser Adapters
+ * PRD-INV-001: Strict Code Intelligence Invariants & Fault Isolation
+ */
+import { extname } from "node:path";
+export class MultiLanguageAstParser {
+    detectLanguage(filePath) {
+        const ext = extname(filePath).toLowerCase();
+        switch (ext) {
+            case ".ts":
+            case ".tsx":
+            case ".mts":
+            case ".cts":
+                return "typescript";
+            case ".js":
+            case ".jsx":
+            case ".mjs":
+            case ".cjs":
+                return "javascript";
+            case ".py":
+                return "python";
+            case ".go":
+                return "go";
+            case ".rs":
+                return "rust";
+            case ".java":
+                return "java";
+            case ".c":
+            case ".h":
+                return "c";
+            case ".cpp":
+            case ".hpp":
+            case ".cc":
+            case ".cxx":
+                return "cpp";
+            case ".json":
+                return "json";
+            case ".yaml":
+            case ".yml":
+                return "yaml";
+            case ".md":
+            case ".markdown":
+                return "markdown";
+            default:
+                return "unknown";
+        }
+    }
+    parse(filePath, content) {
+        const language = this.detectLanguage(filePath);
+        const symbols = [];
+        const imports = [];
+        const exports = [];
+        const calls = [];
+        const diagnostics = [];
+        // Guard against binary or non-text files
+        if (this.isBinary(content)) {
+            diagnostics.push({
+                filePath,
+                range: { start: { line: 1, character: 1 }, end: { line: 1, character: 1 } },
+                message: "File contains binary content or null bytes; skipping AST extraction",
+                severity: "warning",
+            });
+            return {
+                filePath,
+                language,
+                symbols: [],
+                imports: [],
+                exports: [],
+                calls: [],
+                diagnostics,
+                isPartial: true,
+            };
+        }
+        try {
+            const lines = content.split(/\r?\n/);
+            switch (language) {
+                case "typescript":
+                case "javascript":
+                    this.parseTypeScriptJavaScript(filePath, lines, language, symbols, imports, exports, calls);
+                    break;
+                case "python":
+                    this.parsePython(filePath, lines, symbols, imports, calls);
+                    break;
+                case "go":
+                    this.parseGo(filePath, lines, symbols, imports, exports);
+                    break;
+                case "rust":
+                    this.parseRust(filePath, lines, symbols, imports);
+                    break;
+                case "java":
+                    this.parseJava(filePath, lines, symbols, imports);
+                    break;
+                case "c":
+                case "cpp":
+                    this.parseCAndCpp(filePath, lines, language, symbols, imports);
+                    break;
+                case "json":
+                    this.parseJson(filePath, content, symbols, diagnostics);
+                    break;
+                case "yaml":
+                    this.parseYaml(filePath, lines, symbols);
+                    break;
+                case "markdown":
+                    this.parseMarkdown(filePath, lines, symbols);
+                    break;
+                default:
+                    this.parseGeneric(filePath, lines, symbols);
+                    break;
+            }
+            return {
+                filePath,
+                language,
+                symbols,
+                imports,
+                exports,
+                calls,
+                diagnostics,
+                isPartial: false,
+            };
+        }
+        catch (err) {
+            diagnostics.push({
+                filePath,
+                range: { start: { line: 1, character: 1 }, end: { line: 1, character: 1 } },
+                message: err instanceof Error ? err.message : String(err),
+                severity: "error",
+            });
+            return {
+                filePath,
+                language,
+                symbols,
+                imports,
+                exports,
+                calls,
+                diagnostics,
+                isPartial: true,
+                error: err instanceof Error ? err.message : String(err),
+            };
+        }
+    }
+    isBinary(content) {
+        const checkLength = Math.min(content.length, 4096);
+        for (let i = 0; i < checkLength; i++) {
+            if (content.charCodeAt(i) === 0) {
+                return true;
+            }
+        }
+        return false;
+    }
+    parseTypeScriptJavaScript(filePath, lines, language, symbols, imports, exports, calls) {
+        lines.forEach((line, idx) => {
+            const lineNum = idx + 1;
+            // Imports
+            const importMatch = line.match(/^import\s+(?:\{([^}]+)\}|\*\s+as\s+(\w+)|(\w+))\s+from\s+['"]([^'"]+)['"]/);
+            if (importMatch && importMatch[4]) {
+                const source = importMatch[4];
+                const specifiers = [];
+                if (importMatch[1]) {
+                    importMatch[1].split(",").forEach((s) => {
+                        const parts = s.trim().split(/\s+as\s+/);
+                        const name = parts[0];
+                        if (name)
+                            specifiers.push({ name, alias: parts[1] });
+                    });
+                }
+                else if (importMatch[2]) {
+                    specifiers.push({ name: importMatch[2], isNamespace: true });
+                }
+                else if (importMatch[3]) {
+                    specifiers.push({ name: importMatch[3], isDefault: true });
+                }
+                imports.push({
+                    source,
+                    specifiers,
+                    range: {
+                        start: { line: lineNum, character: line.indexOf("import") + 1 },
+                        end: { line: lineNum, character: line.length + 1 },
+                    },
+                });
+            }
+            // Exports
+            const exportMatch = line.match(/export\s+(?:default\s+)?(?:const|let|var|function|class|interface|type|enum)\s+(\w+)/);
+            if (exportMatch && exportMatch[1]) {
+                exports.push({
+                    name: exportMatch[1],
+                    isDefault: line.includes("export default"),
+                    range: {
+                        start: { line: lineNum, character: line.indexOf("export") + 1 },
+                        end: { line: lineNum, character: line.length + 1 },
+                    },
+                });
+            }
+            // Classes
+            const classMatch = line.match(/(?:export\s+)?class\s+(\w+)/);
+            if (classMatch && classMatch[1]) {
+                symbols.push({
+                    id: `${filePath}#${classMatch[1]}:${lineNum}`,
+                    name: classMatch[1],
+                    kind: "class",
+                    language,
+                    filePath,
+                    range: {
+                        start: { line: lineNum, character: line.indexOf(classMatch[1]) + 1 },
+                        end: { line: lineNum, character: line.length + 1 },
+                    },
+                });
+            }
+            // Interfaces
+            const ifaceMatch = line.match(/(?:export\s+)?interface\s+(\w+)/);
+            if (ifaceMatch && ifaceMatch[1]) {
+                symbols.push({
+                    id: `${filePath}#${ifaceMatch[1]}:${lineNum}`,
+                    name: ifaceMatch[1],
+                    kind: "interface",
+                    language,
+                    filePath,
+                    range: {
+                        start: { line: lineNum, character: line.indexOf(ifaceMatch[1]) + 1 },
+                        end: { line: lineNum, character: line.length + 1 },
+                    },
+                });
+            }
+            // Functions
+            const fnMatch = line.match(/(?:export\s+)?(?:async\s+)?function\s+(\w+)/);
+            if (fnMatch && fnMatch[1]) {
+                symbols.push({
+                    id: `${filePath}#${fnMatch[1]}:${lineNum}`,
+                    name: fnMatch[1],
+                    kind: "function",
+                    language,
+                    filePath,
+                    range: {
+                        start: { line: lineNum, character: line.indexOf(fnMatch[1]) + 1 },
+                        end: { line: lineNum, character: line.length + 1 },
+                    },
+                });
+            }
+            // Methods
+            const methodMatch = line.match(/^\s*(?:public|private|protected)?\s*(?:static)?\s*(?:async)?\s*(\w+)\s*\([^)]*\)\s*[:{]/);
+            if (methodMatch && methodMatch[1] && !line.includes("function") && !line.includes("class") && !line.includes("if") && !line.includes("switch")) {
+                symbols.push({
+                    id: `${filePath}#method_${methodMatch[1]}:${lineNum}`,
+                    name: methodMatch[1],
+                    kind: "method",
+                    language,
+                    filePath,
+                    range: {
+                        start: { line: lineNum, character: line.indexOf(methodMatch[1]) + 1 },
+                        end: { line: lineNum, character: line.length + 1 },
+                    },
+                });
+            }
+            // Calls
+            const callMatches = line.matchAll(/\b([a-zA-Z_$][a-zA-Z0-9_$]*)\s*\(/g);
+            for (const cm of callMatches) {
+                const callee = cm[1];
+                if (callee && !["if", "for", "while", "switch", "catch", "function"].includes(callee)) {
+                    calls.push({
+                        calleeName: callee,
+                        filePath,
+                        range: {
+                            start: { line: lineNum, character: (cm.index ?? 0) + 1 },
+                            end: { line: lineNum, character: (cm.index ?? 0) + callee.length + 1 },
+                        },
+                    });
+                }
+            }
+        });
+    }
+    parsePython(filePath, lines, symbols, imports, calls) {
+        lines.forEach((line, idx) => {
+            const lineNum = idx + 1;
+            // Imports
+            const importMatch = line.match(/^import\s+([\w\s,]+)|^from\s+(\w+)\s+import\s+([\w\s,*]+)/);
+            if (importMatch) {
+                const source = importMatch[2] || importMatch[1];
+                if (source) {
+                    imports.push({
+                        source: source.trim(),
+                        specifiers: [],
+                        range: { start: { line: lineNum, character: 1 }, end: { line: lineNum, character: line.length + 1 } },
+                    });
+                }
+            }
+            // Classes
+            const classMatch = line.match(/^class\s+(\w+)/);
+            if (classMatch && classMatch[1]) {
+                symbols.push({
+                    id: `${filePath}#${classMatch[1]}:${lineNum}`,
+                    name: classMatch[1],
+                    kind: "class",
+                    language: "python",
+                    filePath,
+                    range: { start: { line: lineNum, character: 1 }, end: { line: lineNum, character: line.length + 1 } },
+                });
+            }
+            // Functions / Methods
+            const defMatch = line.match(/^\s*def\s+(\w+)/);
+            if (defMatch && defMatch[1]) {
+                const isMethod = line.startsWith("    ") || line.startsWith("\t");
+                symbols.push({
+                    id: `${filePath}#${defMatch[1]}:${lineNum}`,
+                    name: defMatch[1],
+                    kind: isMethod ? "method" : "function",
+                    language: "python",
+                    filePath,
+                    range: { start: { line: lineNum, character: 1 }, end: { line: lineNum, character: line.length + 1 } },
+                });
+            }
+            // Calls
+            const callMatches = line.matchAll(/\b([a-zA-Z_]\w*)\s*\(/g);
+            for (const cm of callMatches) {
+                const callee = cm[1];
+                if (callee && !["def", "class", "if", "for", "while", "elif"].includes(callee)) {
+                    calls.push({
+                        calleeName: callee,
+                        filePath,
+                        range: { start: { line: lineNum, character: (cm.index ?? 0) + 1 }, end: { line: lineNum, character: line.length + 1 } },
+                    });
+                }
+            }
+        });
+    }
+    parseGo(filePath, lines, symbols, imports, exports) {
+        lines.forEach((line, idx) => {
+            const lineNum = idx + 1;
+            // Imports
+            const importMatch = line.match(/^import\s+"([^"]+)"/);
+            if (importMatch && importMatch[1]) {
+                imports.push({
+                    source: importMatch[1],
+                    specifiers: [],
+                    range: { start: { line: lineNum, character: 1 }, end: { line: lineNum, character: line.length + 1 } },
+                });
+            }
+            // Functions & Methods
+            const fnMatch = line.match(/^func\s+(?:\([^)]+\)\s+)?(\w+)/);
+            if (fnMatch && fnMatch[1]) {
+                const name = fnMatch[1];
+                const isExported = name[0] !== undefined && name[0] === name[0].toUpperCase();
+                if (isExported) {
+                    exports.push({
+                        name,
+                        range: { start: { line: lineNum, character: 1 }, end: { line: lineNum, character: line.length + 1 } },
+                    });
+                }
+                symbols.push({
+                    id: `${filePath}#${name}:${lineNum}`,
+                    name,
+                    kind: line.includes("(") && line.indexOf(")") < line.indexOf(name) ? "method" : "function",
+                    language: "go",
+                    filePath,
+                    range: { start: { line: lineNum, character: 1 }, end: { line: lineNum, character: line.length + 1 } },
+                });
+            }
+            // Types / Structs / Interfaces
+            const typeMatch = line.match(/^type\s+(\w+)\s+(struct|interface)/);
+            if (typeMatch && typeMatch[1]) {
+                symbols.push({
+                    id: `${filePath}#${typeMatch[1]}:${lineNum}`,
+                    name: typeMatch[1],
+                    kind: typeMatch[2] === "interface" ? "interface" : "class",
+                    language: "go",
+                    filePath,
+                    range: { start: { line: lineNum, character: 1 }, end: { line: lineNum, character: line.length + 1 } },
+                });
+            }
+        });
+    }
+    parseRust(filePath, lines, symbols, imports) {
+        lines.forEach((line, idx) => {
+            const lineNum = idx + 1;
+            // use statement
+            const useMatch = line.match(/^use\s+([^;]+);/);
+            if (useMatch && useMatch[1]) {
+                imports.push({
+                    source: useMatch[1].trim(),
+                    specifiers: [],
+                    range: { start: { line: lineNum, character: 1 }, end: { line: lineNum, character: line.length + 1 } },
+                });
+            }
+            // struct/enum/trait
+            const structMatch = line.match(/(?:pub\s+)?(struct|enum|trait)\s+(\w+)/);
+            if (structMatch && structMatch[2]) {
+                symbols.push({
+                    id: `${filePath}#${structMatch[2]}:${lineNum}`,
+                    name: structMatch[2],
+                    kind: structMatch[1] === "trait" ? "interface" : structMatch[1] === "enum" ? "enum" : "class",
+                    language: "rust",
+                    filePath,
+                    range: { start: { line: lineNum, character: 1 }, end: { line: lineNum, character: line.length + 1 } },
+                });
+            }
+            // fn
+            const fnMatch = line.match(/(?:pub\s+)?(?:async\s+)?fn\s+(\w+)/);
+            if (fnMatch && fnMatch[1]) {
+                symbols.push({
+                    id: `${filePath}#${fnMatch[1]}:${lineNum}`,
+                    name: fnMatch[1],
+                    kind: "function",
+                    language: "rust",
+                    filePath,
+                    range: { start: { line: lineNum, character: 1 }, end: { line: lineNum, character: line.length + 1 } },
+                });
+            }
+        });
+    }
+    parseJava(filePath, lines, symbols, imports) {
+        lines.forEach((line, idx) => {
+            const lineNum = idx + 1;
+            // Imports
+            const importMatch = line.match(/^import\s+([^;]+);/);
+            if (importMatch && importMatch[1]) {
+                imports.push({
+                    source: importMatch[1].trim(),
+                    specifiers: [],
+                    range: { start: { line: lineNum, character: 1 }, end: { line: lineNum, character: line.length + 1 } },
+                });
+            }
+            // Class / Interface / Enum
+            const classMatch = line.match(/(?:public|protected|private)?\s*(?:static)?\s*(class|interface|enum)\s+(\w+)/);
+            if (classMatch && classMatch[2]) {
+                symbols.push({
+                    id: `${filePath}#${classMatch[2]}:${lineNum}`,
+                    name: classMatch[2],
+                    kind: classMatch[1] === "interface" ? "interface" : classMatch[1] === "enum" ? "enum" : "class",
+                    language: "java",
+                    filePath,
+                    range: { start: { line: lineNum, character: 1 }, end: { line: lineNum, character: line.length + 1 } },
+                });
+            }
+        });
+    }
+    parseCAndCpp(filePath, lines, language, symbols, imports) {
+        lines.forEach((line, idx) => {
+            const lineNum = idx + 1;
+            // #include
+            const incMatch = line.match(/^#include\s+[<"]([^>"]+)[>"]/);
+            if (incMatch && incMatch[1]) {
+                imports.push({
+                    source: incMatch[1],
+                    specifiers: [],
+                    range: { start: { line: lineNum, character: 1 }, end: { line: lineNum, character: line.length + 1 } },
+                });
+            }
+            // struct / class
+            const typeMatch = line.match(/(?:struct|class)\s+(\w+)\s*[{;]/);
+            if (typeMatch && typeMatch[1]) {
+                symbols.push({
+                    id: `${filePath}#${typeMatch[1]}:${lineNum}`,
+                    name: typeMatch[1],
+                    kind: "class",
+                    language,
+                    filePath,
+                    range: { start: { line: lineNum, character: 1 }, end: { line: lineNum, character: line.length + 1 } },
+                });
+            }
+        });
+    }
+    parseJson(filePath, content, symbols, diagnostics) {
+        try {
+            const parsed = JSON.parse(content);
+            if (typeof parsed === "object" && parsed !== null) {
+                Object.keys(parsed).forEach((key, idx) => {
+                    symbols.push({
+                        id: `${filePath}#${key}:${idx + 1}`,
+                        name: key,
+                        kind: "key",
+                        language: "json",
+                        filePath,
+                        range: { start: { line: idx + 1, character: 1 }, end: { line: idx + 1, character: key.length + 1 } },
+                    });
+                });
+            }
+        }
+        catch (e) {
+            diagnostics.push({
+                filePath,
+                range: { start: { line: 1, character: 1 }, end: { line: 1, character: 1 } },
+                message: e instanceof Error ? e.message : "Malformed JSON",
+                severity: "error",
+            });
+        }
+    }
+    parseYaml(filePath, lines, symbols) {
+        lines.forEach((line, idx) => {
+            const lineNum = idx + 1;
+            const keyMatch = line.match(/^([a-zA-Z0-9_-]+):/);
+            if (keyMatch && keyMatch[1]) {
+                symbols.push({
+                    id: `${filePath}#${keyMatch[1]}:${lineNum}`,
+                    name: keyMatch[1],
+                    kind: "key",
+                    language: "yaml",
+                    filePath,
+                    range: { start: { line: lineNum, character: 1 }, end: { line: lineNum, character: line.length + 1 } },
+                });
+            }
+        });
+    }
+    parseMarkdown(filePath, lines, symbols) {
+        lines.forEach((line, idx) => {
+            const lineNum = idx + 1;
+            const headingMatch = line.match(/^(#{1,6})\s+(.+)$/);
+            if (headingMatch && headingMatch[1] && headingMatch[2]) {
+                symbols.push({
+                    id: `${filePath}#heading_${idx}:${lineNum}`,
+                    name: headingMatch[2].trim(),
+                    kind: "module",
+                    language: "markdown",
+                    filePath,
+                    range: { start: { line: lineNum, character: 1 }, end: { line: lineNum, character: line.length + 1 } },
+                    detail: `Level ${headingMatch[1].length}`,
+                });
+            }
+        });
+    }
+    parseGeneric(filePath, lines, symbols) {
+        lines.forEach((line, idx) => {
+            const lineNum = idx + 1;
+            const idMatch = line.match(/^[a-zA-Z_]\w*\s*=/);
+            if (idMatch) {
+                symbols.push({
+                    id: `${filePath}#gen_${idx}:${lineNum}`,
+                    name: idMatch[0].replace("=", "").trim(),
+                    kind: "variable",
+                    language: "unknown",
+                    filePath,
+                    range: { start: { line: lineNum, character: 1 }, end: { line: lineNum, character: line.length + 1 } },
+                });
+            }
+        });
+    }
+}
+//# sourceMappingURL=multi-language-ast-parser.js.map