@codemap-ai/code-index 1.0.0

package/dist/parsers/dart.js

@@ -0,0 +1,353 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parseDartFile = parseDartFile;
+const node_path_1 = __importDefault(require("node:path"));
+const web_tree_sitter_1 = require("web-tree-sitter");
+const shared_js_1 = require("./shared.js");
+const types_js_1 = require("./types.js");
+let parserReady = null;
+function getDartParser() {
+    if (!parserReady) {
+        parserReady = (async () => {
+            await web_tree_sitter_1.Parser.init();
+            const wasmPath = node_path_1.default.resolve(node_path_1.default.dirname(require.resolve("tree-sitter-wasms/package.json")), "out", "tree-sitter-dart.wasm");
+            const language = await web_tree_sitter_1.Language.load(wasmPath);
+            const parser = new web_tree_sitter_1.Parser();
+            parser.setLanguage(language);
+            return { parser, language };
+        })();
+    }
+    return parserReady;
+}
+async function parseDartFile(file, filePathSet, projectImportId) {
+    const content = file.content ?? "";
+    if (!content.trim())
+        return { ...types_js_1.EMPTY_SEMANTICS };
+    let parser;
+    try {
+        ({ parser } = await getDartParser());
+    }
+    catch {
+        return parseDartFileWithRegexFallback(file, filePathSet, projectImportId);
+    }
+    const tree = parser.parse(content);
+    if (!tree)
+        return parseDartFileWithRegexFallback(file, filePathSet, projectImportId);
+    const semantics = {
+        symbols: [],
+        imports: [],
+        exports: [],
+        relationships: [],
+        calls: [],
+        issues: [],
+        externalSymbols: [],
+    };
+    const lines = content.split(/\r?\n/);
+    const seenImportKeys = new Set();
+    const seenSymbolKeys = new Set();
+    walkDartAst(tree.rootNode, (node) => {
+        const directive = parseDartDirective(node.text);
+        if (directive) {
+            addDartImport({
+                directive,
+                file,
+                filePathSet,
+                projectImportId,
+                semantics,
+                seenImportKeys,
+                line: node.startPosition.row + 1,
+                col: node.startPosition.column,
+                endLine: node.endPosition.row + 1,
+                endCol: node.endPosition.column,
+            });
+            return;
+        }
+        const symbol = parseDartSymbol(node.text, node.type, isDartMemberNode(node));
+        if (!symbol)
+            return;
+        const line = node.startPosition.row + 1;
+        const localKey = (0, shared_js_1.buildLocalSymbolKey)(file.path, symbol.kind, symbol.displayName);
+        const stableKey = (0, shared_js_1.buildStableSymbolKey)(file.path, symbol.kind, symbol.displayName, line);
+        if (seenSymbolKeys.has(stableKey))
+            return;
+        seenSymbolKeys.add(stableKey);
+        semantics.symbols.push({
+            localKey,
+            stableKey,
+            displayName: symbol.displayName,
+            kind: symbol.kind,
+            language: file.language,
+            signature: lines[node.startPosition.row]?.trim() ?? null,
+            returnType: null,
+            doc: null,
+            isExported: true,
+            isDefaultExport: false,
+            line,
+            col: Math.max(node.startPosition.column, 0),
+            endLine: node.endPosition.row + 1,
+            endCol: node.endPosition.column,
+            parentSymbolLocalKey: findParentDartSymbolLocalKey(node, file.path),
+        });
+    });
+    return semantics;
+}
+function walkDartAst(node, visitor) {
+    visitor(node);
+    for (let i = 0; i < node.childCount; i++) {
+        const child = node.child(i);
+        if (child)
+            walkDartAst(child, visitor);
+    }
+}
+function parseDartDirective(text) {
+    const match = text.match(/^\s*(import|export|part)\s+['"]([^'"]+)['"]/);
+    if (!match?.[1] || !match[2])
+        return null;
+    return {
+        kind: match[1],
+        moduleSpecifier: match[2],
+    };
+}
+function addDartImport(input) {
+    const importKind = input.directive.kind === "part"
+        ? "include"
+        : input.directive.kind === "export"
+            ? "export_from"
+            : "import";
+    const localKey = (0, shared_js_1.buildImportLocalKey)(input.file.path, importKind, input.directive.moduleSpecifier, input.line, input.col);
+    if (input.seenImportKeys.has(localKey))
+        return;
+    input.seenImportKeys.add(localKey);
+    const resolution = resolveDartImport(input.file.path, input.directive.moduleSpecifier, input.file.language, input.filePathSet);
+    const importDraft = {
+        localKey,
+        moduleSpecifier: input.directive.moduleSpecifier,
+        importKind,
+        isTypeOnly: false,
+        importedNames: [],
+        line: input.line,
+        col: input.col,
+        endLine: input.endLine,
+        endCol: input.endCol,
+        resolutionKind: resolution.resolutionKind,
+        targetPathText: resolution.targetPathText,
+        targetExternalSymbolKey: resolution.targetExternalSymbolKey,
+    };
+    input.semantics.imports.push(importDraft);
+    if (resolution.targetExternalSymbolKey) {
+        input.semantics.externalSymbols.push((0, shared_js_1.createExternalSymbolDraft)(input.projectImportId, input.file.language, input.directive.moduleSpecifier));
+    }
+    if (resolution.resolutionKind === "unresolved") {
+        input.semantics.issues.push({
+            projectImportId: input.projectImportId,
+            severity: "warning",
+            code: "UNRESOLVED_IMPORT",
+            message: `Unable to resolve ${input.directive.kind} "${input.directive.moduleSpecifier}" from ${input.file.path}`,
+            detailJson: {
+                filePath: input.file.path,
+                moduleSpecifier: input.directive.moduleSpecifier,
+                kind: input.directive.kind,
+            },
+        });
+    }
+    if (input.directive.kind === "export") {
+        input.semantics.exports.push({
+            exportName: input.directive.moduleSpecifier,
+            exportKind: "re_export",
+            line: input.line,
+            col: input.col,
+            endLine: input.endLine,
+            endCol: input.endCol,
+            sourceImportLocalKey: localKey,
+            targetExternalSymbolKey: resolution.targetExternalSymbolKey,
+        });
+    }
+}
+function resolveDartImport(filePath, moduleSpecifier, language, filePathSet) {
+    if (moduleSpecifier.startsWith("dart:")) {
+        return {
+            resolutionKind: "builtin",
+            targetPathText: null,
+            targetExternalSymbolKey: `dart:${moduleSpecifier}`,
+        };
+    }
+    if (moduleSpecifier.startsWith("package:")) {
+        const packagePath = moduleSpecifier.replace(/^package:[^/]+\//, "");
+        const internalTarget = packagePath ? `lib/${packagePath}` : null;
+        if (internalTarget && filePathSet.has(internalTarget)) {
+            return {
+                resolutionKind: "relative_path",
+                targetPathText: internalTarget,
+                targetExternalSymbolKey: null,
+            };
+        }
+        return {
+            resolutionKind: "package",
+            targetPathText: null,
+            targetExternalSymbolKey: `dart:${moduleSpecifier}`,
+        };
+    }
+    const resolution = (0, shared_js_1.resolveRelativeTargetPath)(filePath, moduleSpecifier, language, filePathSet);
+    return {
+        resolutionKind: resolution.resolvedPath ? "relative_path" : "unresolved",
+        targetPathText: resolution.resolvedPath ?? resolution.attemptedPath,
+        targetExternalSymbolKey: null,
+    };
+}
+function parseDartSymbol(text, nodeType, isMemberNode) {
+    const trimmed = text.trim();
+    const declarationMatch = trimmed.match(/^(?:(?:abstract|base|final|interface|sealed)\s+)*(class|mixin|enum)\s+([A-Za-z_]\w*)/);
+    if (declarationMatch?.[1] && declarationMatch[2]) {
+        return {
+            kind: declarationMatch[1] === "mixin" ? "mixin" : declarationMatch[1],
+            displayName: declarationMatch[2],
+        };
+    }
+    const extensionMatch = trimmed.match(/^extension(?:\s+type)?\s+([A-Za-z_]\w*)\b/);
+    if (extensionMatch?.[1] && extensionMatch[1] !== "on") {
+        return { kind: "mixin", displayName: extensionMatch[1] };
+    }
+    const typeAliasMatch = trimmed.match(/^typedef\s+([A-Za-z_]\w*)\b/);
+    if (typeAliasMatch?.[1]) {
+        return { kind: "type_alias", displayName: typeAliasMatch[1] };
+    }
+    if (!/\b(function|method|constructor|declaration|signature)\b/i.test(nodeType)) {
+        return null;
+    }
+    const callableMatch = trimmed.match(/^(?:(?:static|external|abstract|factory|const|late|final)\s+)*(?:[A-Za-z_]\w*(?:<[^>{}]+>)?(?:[?*])?\s+)?([A-Za-z_]\w*)\s*(?:<[^>{}]+>)?\(/);
+    if (!callableMatch?.[1] || ["if", "for", "while", "switch", "catch", "assert"].includes(callableMatch[1])) {
+        return null;
+    }
+    return {
+        kind: isMemberNode ? "method" : "function",
+        displayName: callableMatch[1],
+    };
+}
+function isDartMemberNode(node) {
+    let current = node.parent;
+    while (current) {
+        const trimmed = current.text.trimStart();
+        if (/^(?:(?:abstract|base|final|interface|sealed)\s+)*class\s+/.test(trimmed))
+            return true;
+        if (/^(?:base\s+)?mixin\s+/.test(trimmed))
+            return true;
+        if (/^extension(?:\s+type)?\s+/.test(trimmed))
+            return true;
+        current = current.parent;
+    }
+    return false;
+}
+function findParentDartSymbolLocalKey(node, filePath) {
+    let current = node.parent;
+    while (current) {
+        const parentSymbol = parseDartSymbol(current.text, current.type, false);
+        if (parentSymbol && ["class", "mixin", "enum"].includes(parentSymbol.kind)) {
+            return (0, shared_js_1.buildLocalSymbolKey)(filePath, parentSymbol.kind, parentSymbol.displayName);
+        }
+        current = current.parent;
+    }
+    return undefined;
+}
+function parseDartFileWithRegexFallback(file, filePathSet, projectImportId) {
+    const semantics = {
+        symbols: [],
+        imports: [],
+        exports: [],
+        relationships: [],
+        calls: [],
+        issues: [],
+        externalSymbols: [],
+    };
+    const originalLines = (file.content ?? "").split(/\r?\n/);
+    const lines = (0, shared_js_1.maskCommentsAndTemplateLiterals)(file.content ?? "").split(/\r?\n/);
+    const seenImportKeys = new Set();
+    const containerStack = [];
+    let braceDepth = 0;
+    lines.forEach((line, index) => {
+        const originalLine = originalLines[index] ?? line;
+        const lineNumber = index + 1;
+        while (containerStack.length > 0 && braceDepth < containerStack[containerStack.length - 1].depth) {
+            containerStack.pop();
+        }
+        const parentContainer = containerStack[containerStack.length - 1];
+        let matchedContainerSymbol = null;
+        for (const match of line.matchAll(/^\s*(import|export|part)\s+['"]([^'"]+)['"]/g)) {
+            const kind = match[1];
+            const moduleSpecifier = match[2];
+            if (!kind || !moduleSpecifier)
+                continue;
+            addDartImport({
+                directive: { kind, moduleSpecifier },
+                file,
+                filePathSet,
+                projectImportId,
+                semantics,
+                seenImportKeys,
+                line: lineNumber,
+                col: match.index ?? 0,
+                endLine: lineNumber,
+                endCol: (match.index ?? 0) + match[0].length,
+            });
+        }
+        const symbolPatterns = [
+            { regex: /^\s*(?:(?:abstract|base|final|interface|sealed)\s+)*class\s+([A-Za-z_]\w*)/, kind: "class" },
+            { regex: /^\s*(?:base\s+)?mixin\s+([A-Za-z_]\w*)/, kind: "mixin" },
+            { regex: /^\s*extension(?:\s+type)?\s+([A-Za-z_]\w*)/, kind: "mixin" },
+            { regex: /^\s*enum\s+([A-Za-z_]\w*)/, kind: "enum" },
+            { regex: /^\s*typedef\s+([A-Za-z_]\w*)/, kind: "type_alias" },
+        ];
+        for (const pattern of symbolPatterns) {
+            const match = line.match(pattern.regex);
+            if (!match?.[1] || match[1] === "on")
+                continue;
+            const displayName = match[1];
+            const col = line.indexOf(displayName);
+            const symbol = buildDartRegexSymbol(file, pattern.kind, displayName, originalLine, lineNumber, col);
+            semantics.symbols.push(symbol);
+            if (pattern.kind === "class" || pattern.kind === "mixin" || pattern.kind === "enum") {
+                matchedContainerSymbol = { kind: pattern.kind, displayName };
+            }
+            break;
+        }
+        const functionMatch = line.match(/^\s*(?:(?:static|external|factory|const)\s+)*(?:[A-Za-z_]\w*(?:<[^>{}]+>)?(?:[?*])?\s+)?([A-Za-z_]\w*)\s*(?:<[^>{}]+>)?\([^;{}]*\)\s*(?:async\s*)?(?:=>|{|$)/);
+        if (functionMatch?.[1] && !["if", "for", "while", "switch", "catch", "assert"].includes(functionMatch[1])) {
+            const displayName = functionMatch[1];
+            const kind = parentContainer ? "method" : "function";
+            const col = line.indexOf(displayName);
+            const symbol = buildDartRegexSymbol(file, kind, displayName, originalLine, lineNumber, col);
+            if (parentContainer) {
+                symbol.parentSymbolLocalKey = (0, shared_js_1.buildLocalSymbolKey)(file.path, parentContainer.kind, parentContainer.displayName);
+            }
+            semantics.symbols.push(symbol);
+        }
+        const openBraces = (line.match(/{/g) ?? []).length;
+        const closeBraces = (line.match(/}/g) ?? []).length;
+        const nextBraceDepth = braceDepth + openBraces - closeBraces;
+        if (matchedContainerSymbol && openBraces > 0) {
+            containerStack.push({ ...matchedContainerSymbol, depth: braceDepth + 1 });
+        }
+        braceDepth = nextBraceDepth;
+    });
+    return semantics;
+}
+function buildDartRegexSymbol(file, kind, displayName, line, lineNumber, col) {
+    return {
+        localKey: (0, shared_js_1.buildLocalSymbolKey)(file.path, kind, displayName),
+        stableKey: (0, shared_js_1.buildStableSymbolKey)(file.path, kind, displayName, lineNumber),
+        displayName,
+        kind,
+        language: file.language,
+        signature: line.trim(),
+        returnType: null,
+        doc: null,
+        isExported: false,
+        isDefaultExport: false,
+        line: lineNumber,
+        col: Math.max(col, 0),
+        endLine: lineNumber,
+        endCol: Math.max(col, 0) + displayName.length,
+    };
+}

package/dist/parsers/index.d.ts

@@ -0,0 +1,11 @@
+import type { WorkspaceFileCandidate } from "../file-discovery.js";
+import type { TypeScriptResolverConfig } from "../ts-resolver.js";
+export type { ParsedWorkspaceSemantics } from "./types.js";
+export declare function parseWorkspaceFileSemantics(input: {
+    file: WorkspaceFileCandidate;
+    filePathSet: Set<string>;
+    projectImportId: string;
+    workspacePath: string;
+    resolverConfigs?: TypeScriptResolverConfig[];
+}): Promise<import("./types.js").ParsedWorkspaceSemantics>;
+//# sourceMappingURL=index.d.ts.map

package/dist/parsers/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/parsers/index.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,sBAAsB,EAAE,MAAM,sBAAsB,CAAC;AACnE,OAAO,KAAK,EAAE,wBAAwB,EAAE,MAAM,mBAAmB,CAAC;AASlE,YAAY,EAAE,wBAAwB,EAAE,MAAM,YAAY,CAAC;AAE3D,wBAAsB,2BAA2B,CAAC,KAAK,EAAE;IACvD,IAAI,EAAE,sBAAsB,CAAC;IAC7B,WAAW,EAAE,GAAG,CAAC,MAAM,CAAC,CAAC;IACzB,eAAe,EAAE,MAAM,CAAC;IACxB,aAAa,EAAE,MAAM,CAAC;IACtB,eAAe,CAAC,EAAE,wBAAwB,EAAE,CAAC;CAC9C,0DA4BA"}

package/dist/parsers/index.js

@@ -0,0 +1,32 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parseWorkspaceFileSemantics = parseWorkspaceFileSemantics;
+const dart_js_1 = require("./dart.js");
+const java_js_1 = require("./java.js");
+const kotlin_js_1 = require("./kotlin.js");
+const php_js_1 = require("./php.js");
+const python_js_1 = require("./python.js");
+const typescript_js_1 = require("./typescript.js");
+const types_js_1 = require("./types.js");
+async function parseWorkspaceFileSemantics(input) {
+    if (!input.file.language || !input.file.content) {
+        return { ...types_js_1.EMPTY_SEMANTICS };
+    }
+    switch (input.file.language) {
+        case "TypeScript":
+        case "JavaScript":
+            return (0, typescript_js_1.parseTypeScriptOrJavaScriptFile)(input.file, input.filePathSet, input.projectImportId, input.workspacePath, input.resolverConfigs ?? []);
+        case "Dart":
+            return (0, dart_js_1.parseDartFile)(input.file, input.filePathSet, input.projectImportId);
+        case "Java":
+            return (0, java_js_1.parseJavaFile)(input.file, input.projectImportId);
+        case "Kotlin":
+            return (0, kotlin_js_1.parseKotlinFile)(input.file, input.projectImportId);
+        case "PHP":
+            return (0, php_js_1.parsePhpFile)(input.file, input.projectImportId);
+        case "Python":
+            return (0, python_js_1.parsePythonFile)(input.file, input.filePathSet, input.projectImportId);
+        default:
+            return { ...types_js_1.EMPTY_SEMANTICS };
+    }
+}

package/dist/parsers/java.d.ts

@@ -0,0 +1,4 @@
+import type { WorkspaceFileCandidate } from "../file-discovery.js";
+import { type ParsedWorkspaceSemantics } from "./types.js";
+export declare function parseJavaFile(file: WorkspaceFileCandidate, projectImportId: string): Promise<ParsedWorkspaceSemantics>;
+//# sourceMappingURL=java.d.ts.map

package/dist/parsers/java.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"java.d.ts","sourceRoot":"","sources":["../../src/parsers/java.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,sBAAsB,EAAE,MAAM,sBAAsB,CAAC;AAEnE,OAAO,EAA2C,KAAK,wBAAwB,EAAuB,MAAM,YAAY,CAAC;AAsBzH,wBAAsB,aAAa,CACjC,IAAI,EAAE,sBAAsB,EAC5B,eAAe,EAAE,MAAM,GACtB,OAAO,CAAC,wBAAwB,CAAC,CAoDnC"}

package/dist/parsers/java.js

@@ -0,0 +1,222 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parseJavaFile = parseJavaFile;
+const node_path_1 = __importDefault(require("node:path"));
+const web_tree_sitter_1 = require("web-tree-sitter");
+const shared_js_1 = require("./shared.js");
+const types_js_1 = require("./types.js");
+let parserReady = null;
+function getJavaParser() {
+    if (!parserReady) {
+        parserReady = (async () => {
+            await web_tree_sitter_1.Parser.init();
+            const wasmPath = node_path_1.default.resolve(node_path_1.default.dirname(require.resolve("tree-sitter-wasms/package.json")), "out", "tree-sitter-java.wasm");
+            const language = await web_tree_sitter_1.Language.load(wasmPath);
+            const parser = new web_tree_sitter_1.Parser();
+            parser.setLanguage(language);
+            return { parser, language };
+        })();
+    }
+    return parserReady;
+}
+async function parseJavaFile(file, projectImportId) {
+    const content = file.content ?? "";
+    if (!content.trim())
+        return { ...types_js_1.EMPTY_SEMANTICS };
+    let parser;
+    try {
+        ({ parser } = await getJavaParser());
+    }
+    catch {
+        return parseJavaFileWithRegexFallback(file, projectImportId);
+    }
+    const tree = parser.parse(content);
+    if (!tree)
+        return parseJavaFileWithRegexFallback(file, projectImportId);
+    const semantics = createEmptySemantics();
+    const lines = content.split(/\r?\n/);
+    const seenSymbols = new Set();
+    const seenImports = new Set();
+    walkJavaAst(tree.rootNode, (node) => {
+        const line = node.startPosition.row + 1;
+        const col = node.startPosition.column;
+        const packageName = parseJavaPackage(node.text);
+        if (packageName) {
+            addJavaSymbol(semantics, seenSymbols, file, "namespace", packageName, lines[node.startPosition.row] ?? node.text, line, col, node.endPosition.row + 1, node.endPosition.column);
+            return;
+        }
+        const importName = parseJavaImport(node.text);
+        if (importName) {
+            addJavaImport(semantics, seenImports, file, projectImportId, importName, line, col, node.endPosition.row + 1, node.endPosition.column);
+            return;
+        }
+        const symbol = parseJavaSymbol(node.text, node.type, isJavaMemberNode(node));
+        if (!symbol)
+            return;
+        addJavaSymbol(semantics, seenSymbols, file, symbol.kind, symbol.displayName, lines[node.startPosition.row] ?? node.text, line, col, node.endPosition.row + 1, node.endPosition.column, findParentJavaSymbolLocalKey(node, file.path));
+    });
+    return semantics;
+}
+function createEmptySemantics() {
+    return {
+        symbols: [],
+        imports: [],
+        exports: [],
+        relationships: [],
+        calls: [],
+        issues: [],
+        externalSymbols: [],
+    };
+}
+function walkJavaAst(node, visitor) {
+    visitor(node);
+    for (let i = 0; i < node.childCount; i++) {
+        const child = node.child(i);
+        if (child)
+            walkJavaAst(child, visitor);
+    }
+}
+function parseJavaPackage(text) {
+    return text.trim().match(/^package\s+([A-Za-z_]\w*(?:\.[A-Za-z_]\w*)*)\s*;/)?.[1] ?? null;
+}
+function parseJavaImport(text) {
+    return text.trim().match(/^import\s+(?:static\s+)?([A-Za-z_]\w*(?:\.[A-Za-z_]\w*)*(?:\.\*)?)\s*;/)?.[1] ?? null;
+}
+function parseJavaSymbol(text, nodeType, isMemberNode) {
+    const trimmed = text.trim();
+    const typeMatch = trimmed.match(/^(?:(?:public|protected|private|abstract|static|final|sealed|non-sealed|strictfp)\s+)*(class|interface|enum|record|@interface)\s+([A-Za-z_]\w*)/);
+    if (typeMatch?.[1] && typeMatch[2]) {
+        const kind = typeMatch[1] === "interface" || typeMatch[1] === "@interface"
+            ? "interface"
+            : typeMatch[1] === "enum"
+                ? "enum"
+                : "class";
+        return { displayName: typeMatch[2], kind };
+    }
+    if (!/\b(method|constructor|declaration)\b/i.test(nodeType))
+        return null;
+    const methodMatch = trimmed.match(/^(?:(?:public|protected|private|abstract|static|final|synchronized|native|strictfp)\s+)*(?:<[^>{}]+>\s*)?(?:(?:[A-Za-z_]\w*(?:<[^>{}]+>)?(?:\[\])?|\w+\.\w+)\s+)?([A-Za-z_]\w*)\s*\(/);
+    if (!methodMatch?.[1] || ["if", "for", "while", "switch", "catch", "try"].includes(methodMatch[1])) {
+        return null;
+    }
+    return { displayName: methodMatch[1], kind: isMemberNode ? "method" : "function" };
+}
+function isJavaMemberNode(node) {
+    let current = node.parent;
+    while (current) {
+        if (/^(?:(?:public|protected|private|abstract|static|final|sealed|non-sealed|strictfp)\s+)*(class|interface|enum|record|@interface)\s+/.test(current.text.trimStart())) {
+            return true;
+        }
+        current = current.parent;
+    }
+    return false;
+}
+function findParentJavaSymbolLocalKey(node, filePath) {
+    let current = node.parent;
+    while (current) {
+        const parentSymbol = parseJavaSymbol(current.text, current.type, false);
+        if (parentSymbol && ["class", "interface", "enum"].includes(parentSymbol.kind)) {
+            return (0, shared_js_1.buildLocalSymbolKey)(filePath, parentSymbol.kind, parentSymbol.displayName);
+        }
+        current = current.parent;
+    }
+    return undefined;
+}
+function addJavaImport(semantics, seenImports, file, projectImportId, moduleSpecifier, line, col, endLine, endCol) {
+    const localKey = (0, shared_js_1.buildImportLocalKey)(file.path, "import", moduleSpecifier, line, col);
+    if (seenImports.has(localKey))
+        return;
+    seenImports.add(localKey);
+    semantics.imports.push({
+        localKey,
+        moduleSpecifier,
+        importKind: "import",
+        isTypeOnly: false,
+        importedNames: [moduleSpecifier.split(".").pop() ?? moduleSpecifier],
+        line,
+        col,
+        endLine,
+        endCol,
+        resolutionKind: "package",
+        targetPathText: null,
+        targetExternalSymbolKey: `java:${moduleSpecifier}`,
+    });
+    semantics.externalSymbols.push((0, shared_js_1.createExternalSymbolDraft)(projectImportId, file.language, moduleSpecifier));
+}
+function addJavaSymbol(semantics, seenSymbols, file, kind, displayName, signature, line, col, endLine, endCol, parentSymbolLocalKey) {
+    const stableKey = (0, shared_js_1.buildStableSymbolKey)(file.path, kind, displayName, line);
+    if (seenSymbols.has(stableKey))
+        return;
+    seenSymbols.add(stableKey);
+    semantics.symbols.push({
+        localKey: (0, shared_js_1.buildLocalSymbolKey)(file.path, kind, displayName),
+        stableKey,
+        displayName,
+        kind,
+        language: file.language,
+        signature: signature.trim(),
+        returnType: null,
+        doc: null,
+        isExported: true,
+        isDefaultExport: false,
+        line,
+        col,
+        endLine,
+        endCol,
+        parentSymbolLocalKey,
+    });
+}
+function parseJavaFileWithRegexFallback(file, projectImportId) {
+    const semantics = createEmptySemantics();
+    const lines = (0, shared_js_1.maskCommentsAndTemplateLiterals)(file.content ?? "").split(/\r?\n/);
+    const originalLines = (file.content ?? "").split(/\r?\n/);
+    const seenSymbols = new Set();
+    const seenImports = new Set();
+    const containerStack = [];
+    let braceDepth = 0;
+    lines.forEach((line, index) => {
+        const originalLine = originalLines[index] ?? line;
+        const lineNumber = index + 1;
+        while (containerStack.length > 0 && braceDepth < containerStack[containerStack.length - 1].depth) {
+            containerStack.pop();
+        }
+        const parentContainer = containerStack[containerStack.length - 1];
+        let matchedContainer = null;
+        const packageName = parseJavaPackage(line);
+        if (packageName) {
+            addJavaSymbol(semantics, seenSymbols, file, "namespace", packageName, originalLine, lineNumber, line.indexOf(packageName), lineNumber, line.length);
+        }
+        const importName = parseJavaImport(line);
+        if (importName) {
+            addJavaImport(semantics, seenImports, file, projectImportId, importName, lineNumber, line.indexOf(importName), lineNumber, line.length);
+        }
+        const typeMatch = line.match(/^\s*(?:(?:public|protected|private|abstract|static|final|sealed|non-sealed|strictfp)\s+)*(class|interface|enum|record|@interface)\s+([A-Za-z_]\w*)/);
+        if (typeMatch?.[1] && typeMatch[2]) {
+            const kind = typeMatch[1] === "interface" || typeMatch[1] === "@interface"
+                ? "interface"
+                : typeMatch[1] === "enum"
+                    ? "enum"
+                    : "class";
+            addJavaSymbol(semantics, seenSymbols, file, kind, typeMatch[2], originalLine, lineNumber, line.indexOf(typeMatch[2]), lineNumber, line.length);
+            matchedContainer = { kind, displayName: typeMatch[2] };
+        }
+        const methodMatch = line.match(/^\s*(?:(?:public|protected|private|abstract|static|final|synchronized|native|strictfp)\s+)*(?:<[^>{}]+>\s*)?(?:(?:[A-Za-z_]\w*(?:<[^>{}]+>)?(?:\[\])?|\w+\.\w+)\s+)?([A-Za-z_]\w*)\s*\([^;{}]*\)\s*(?:throws\s+[^{]+)?(?:\{|$)/);
+        if (methodMatch?.[1] && !["if", "for", "while", "switch", "catch", "try"].includes(methodMatch[1])) {
+            const kind = parentContainer ? "method" : "function";
+            const parentSymbolLocalKey = parentContainer
+                ? (0, shared_js_1.buildLocalSymbolKey)(file.path, parentContainer.kind, parentContainer.displayName)
+                : undefined;
+            addJavaSymbol(semantics, seenSymbols, file, kind, methodMatch[1], originalLine, lineNumber, line.indexOf(methodMatch[1]), lineNumber, line.length, parentSymbolLocalKey);
+        }
+        const openBraces = (line.match(/{/g) ?? []).length;
+        const closeBraces = (line.match(/}/g) ?? []).length;
+        if (matchedContainer && openBraces > 0) {
+            containerStack.push({ ...matchedContainer, depth: braceDepth + 1 });
+        }
+        braceDepth += openBraces - closeBraces;
+    });
+    return semantics;
+}

package/dist/parsers/kotlin.d.ts

@@ -0,0 +1,4 @@
+import type { WorkspaceFileCandidate } from "../file-discovery.js";
+import { type ParsedWorkspaceSemantics } from "./types.js";
+export declare function parseKotlinFile(file: WorkspaceFileCandidate, projectImportId: string): Promise<ParsedWorkspaceSemantics>;
+//# sourceMappingURL=kotlin.d.ts.map

package/dist/parsers/kotlin.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"kotlin.d.ts","sourceRoot":"","sources":["../../src/parsers/kotlin.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,sBAAsB,EAAE,MAAM,sBAAsB,CAAC;AAEnE,OAAO,EAA2C,KAAK,wBAAwB,EAAuB,MAAM,YAAY,CAAC;AAsBzH,wBAAsB,eAAe,CACnC,IAAI,EAAE,sBAAsB,EAC5B,eAAe,EAAE,MAAM,GACtB,OAAO,CAAC,wBAAwB,CAAC,CAoDnC"}