@codemap-ai/code-index 1.0.0

package/dist/parsers/kotlin.js

@@ -0,0 +1,221 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parseKotlinFile = parseKotlinFile;
+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 getKotlinParser() {
+    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-kotlin.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 parseKotlinFile(file, projectImportId) {
+    const content = file.content ?? "";
+    if (!content.trim())
+        return { ...types_js_1.EMPTY_SEMANTICS };
+    let parser;
+    try {
+        ({ parser } = await getKotlinParser());
+    }
+    catch {
+        return parseKotlinFileWithRegexFallback(file, projectImportId);
+    }
+    const tree = parser.parse(content);
+    if (!tree)
+        return parseKotlinFileWithRegexFallback(file, projectImportId);
+    const semantics = createEmptySemantics();
+    const lines = content.split(/\r?\n/);
+    const seenSymbols = new Set();
+    const seenImports = new Set();
+    walkKotlinAst(tree.rootNode, (node) => {
+        const line = node.startPosition.row + 1;
+        const col = node.startPosition.column;
+        const packageName = parseKotlinPackage(node.text);
+        if (packageName) {
+            addKotlinSymbol(semantics, seenSymbols, file, "namespace", packageName, lines[node.startPosition.row] ?? node.text, line, col, node.endPosition.row + 1, node.endPosition.column);
+            return;
+        }
+        const importName = parseKotlinImport(node.text);
+        if (importName) {
+            addKotlinImport(semantics, seenImports, file, projectImportId, importName, line, col, node.endPosition.row + 1, node.endPosition.column);
+            return;
+        }
+        const symbol = parseKotlinSymbol(node.text, isKotlinMemberNode(node));
+        if (!symbol)
+            return;
+        addKotlinSymbol(semantics, seenSymbols, file, symbol.kind, symbol.displayName, lines[node.startPosition.row] ?? node.text, line, col, node.endPosition.row + 1, node.endPosition.column, findParentKotlinSymbolLocalKey(node, file.path));
+    });
+    return semantics;
+}
+function createEmptySemantics() {
+    return {
+        symbols: [],
+        imports: [],
+        exports: [],
+        relationships: [],
+        calls: [],
+        issues: [],
+        externalSymbols: [],
+    };
+}
+function walkKotlinAst(node, visitor) {
+    visitor(node);
+    for (let i = 0; i < node.childCount; i++) {
+        const child = node.child(i);
+        if (child)
+            walkKotlinAst(child, visitor);
+    }
+}
+function parseKotlinPackage(text) {
+    return text.trim().match(/^package\s+([A-Za-z_]\w*(?:\.[A-Za-z_]\w*)*)/)?.[1] ?? null;
+}
+function parseKotlinImport(text) {
+    return text.trim().match(/^import\s+([A-Za-z_]\w*(?:\.[A-Za-z_]\w*)*(?:\.\*)?)(?:\s+as\s+[A-Za-z_]\w*)?/)?.[1] ?? null;
+}
+function parseKotlinSymbol(text, isMemberNode) {
+    const trimmed = text.trim();
+    const typeMatch = trimmed.match(/^(?:(?:public|protected|private|internal|open|abstract|sealed|data|value|inner|companion)\s+)*(class|interface|object|enum\s+class)\s+([A-Za-z_]\w*)/);
+    if (typeMatch?.[1] && typeMatch[2]) {
+        const kind = typeMatch[1] === "interface"
+            ? "interface"
+            : typeMatch[1] === "enum class"
+                ? "enum"
+                : "class";
+        return { displayName: typeMatch[2], kind };
+    }
+    const funMatch = trimmed.match(/^(?:(?:public|protected|private|internal|open|override|suspend|inline|tailrec|operator|infix|external)\s+)*fun\s+(?:[A-Za-z_]\w*\.)?([A-Za-z_]\w*)\s*(?:<[^>{}]+>)?\(/);
+    if (funMatch?.[1]) {
+        return { displayName: funMatch[1], kind: isMemberNode ? "method" : "function" };
+    }
+    const propertyMatch = trimmed.match(/^(?:(?:public|protected|private|internal|open|override|lateinit|const)\s+)*(val|var)\s+([A-Za-z_]\w*)\b/);
+    if (propertyMatch?.[2]) {
+        return { displayName: propertyMatch[2], kind: isMemberNode ? "property" : "variable" };
+    }
+    return null;
+}
+function isKotlinMemberNode(node) {
+    let current = node.parent;
+    while (current) {
+        if (/^(?:(?:public|protected|private|internal|open|abstract|sealed|data|value|inner|companion)\s+)*(class|interface|object|enum\s+class)\s+/.test(current.text.trimStart())) {
+            return true;
+        }
+        current = current.parent;
+    }
+    return false;
+}
+function findParentKotlinSymbolLocalKey(node, filePath) {
+    let current = node.parent;
+    while (current) {
+        const parentSymbol = parseKotlinSymbol(current.text, 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 addKotlinImport(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: `kotlin:${moduleSpecifier}`,
+    });
+    semantics.externalSymbols.push((0, shared_js_1.createExternalSymbolDraft)(projectImportId, file.language, moduleSpecifier));
+}
+function addKotlinSymbol(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 parseKotlinFileWithRegexFallback(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 = parseKotlinPackage(line);
+        if (packageName) {
+            addKotlinSymbol(semantics, seenSymbols, file, "namespace", packageName, originalLine, lineNumber, line.indexOf(packageName), lineNumber, line.length);
+        }
+        const importName = parseKotlinImport(line);
+        if (importName) {
+            addKotlinImport(semantics, seenImports, file, projectImportId, importName, lineNumber, line.indexOf(importName), lineNumber, line.length);
+        }
+        const typeSymbol = parseKotlinSymbol(line, false);
+        if (typeSymbol && ["class", "interface", "enum"].includes(typeSymbol.kind)) {
+            addKotlinSymbol(semantics, seenSymbols, file, typeSymbol.kind, typeSymbol.displayName, originalLine, lineNumber, line.indexOf(typeSymbol.displayName), lineNumber, line.length);
+            matchedContainer = {
+                kind: typeSymbol.kind,
+                displayName: typeSymbol.displayName,
+            };
+        }
+        const funSymbol = parseKotlinSymbol(line, Boolean(parentContainer));
+        if (funSymbol && (funSymbol.kind === "function" || funSymbol.kind === "method" || funSymbol.kind === "property" || funSymbol.kind === "variable")) {
+            const parentSymbolLocalKey = parentContainer
+                ? (0, shared_js_1.buildLocalSymbolKey)(file.path, parentContainer.kind, parentContainer.displayName)
+                : undefined;
+            addKotlinSymbol(semantics, seenSymbols, file, funSymbol.kind, funSymbol.displayName, originalLine, lineNumber, line.indexOf(funSymbol.displayName), 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/php.d.ts

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

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

@@ -0,0 +1 @@
+{"version":3,"file":"php.d.ts","sourceRoot":"","sources":["../../src/parsers/php.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,sBAAsB,EAAE,MAAM,sBAAsB,CAAC;AAEnE,OAAO,EAAmB,KAAK,wBAAwB,EAAE,MAAM,YAAY,CAAC;AAsB5E,wBAAsB,YAAY,CAChC,IAAI,EAAE,sBAAsB,EAC5B,eAAe,EAAE,MAAM,GACtB,OAAO,CAAC,wBAAwB,CAAC,CA6HnC"}

package/dist/parsers/php.js

@@ -0,0 +1,215 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parsePhpFile = parsePhpFile;
+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 getPhpParser() {
+    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-php.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 parsePhpFile(file, projectImportId) {
+    const content = file.content ?? "";
+    if (!content.trim())
+        return { ...types_js_1.EMPTY_SEMANTICS };
+    let parser;
+    let language;
+    try {
+        ({ parser, language } = await getPhpParser());
+    }
+    catch {
+        return parsePhpFileWithRegexFallback(file, projectImportId);
+    }
+    const tree = parser.parse(content);
+    if (!tree)
+        return parsePhpFileWithRegexFallback(file, projectImportId);
+    const semantics = {
+        symbols: [],
+        imports: [],
+        exports: [],
+        relationships: [],
+        calls: [],
+        issues: [],
+        externalSymbols: [],
+    };
+    const lines = content.split(/\r?\n/);
+    // Extract symbols: namespace, class, interface, trait, enum, function, method
+    const symbolQuery = new web_tree_sitter_1.Query(language, `
+    (namespace_definition name: (namespace_name) @name) @namespace
+    (class_declaration name: (name) @name) @class
+    (interface_declaration name: (name) @name) @interface
+    (trait_declaration name: (name) @name) @trait
+    (enum_declaration name: (name) @name) @enum
+    (function_definition name: (name) @name) @function
+    (method_declaration name: (name) @name) @method
+  `);
+    for (const match of symbolQuery.matches(tree.rootNode)) {
+        const defCapture = match.captures.find((c) => ["namespace", "class", "interface", "trait", "enum", "function", "method"].includes(c.name));
+        const nameCapture = match.captures.find((c) => c.name === "name");
+        if (!defCapture || !nameCapture)
+            continue;
+        const captureName = defCapture.name;
+        const kind = captureName === "namespace" ? "namespace" : captureName;
+        const displayName = nameCapture.node.text;
+        const startPos = defCapture.node.startPosition;
+        const endPos = defCapture.node.endPosition;
+        const line = startPos.row + 1;
+        const col = startPos.column;
+        semantics.symbols.push({
+            localKey: (0, shared_js_1.buildLocalSymbolKey)(file.path, kind, displayName),
+            stableKey: (0, shared_js_1.buildStableSymbolKey)(file.path, kind, displayName, line),
+            displayName,
+            kind,
+            language: file.language,
+            signature: lines[startPos.row]?.trim() ?? null,
+            returnType: null,
+            doc: null,
+            isExported: true,
+            isDefaultExport: false,
+            line,
+            col,
+            endLine: endPos.row + 1,
+            endCol: endPos.column,
+        });
+    }
+    // Extract use statements and require/include
+    const importQuery = new web_tree_sitter_1.Query(language, `
+    (use_declaration (use_declarator (qualified_name) @name)) @use
+    (namespace_use_declaration (namespace_use_clause (qualified_name) @name)) @use
+    (require_expression (string) @path) @require
+    (require_once_expression (string) @path) @require_once
+    (include_expression (string) @path) @include
+    (include_once_expression (string) @path) @include_once
+  `);
+    const seenImportKeys = new Set();
+    for (const match of importQuery.matches(tree.rootNode)) {
+        const stmtCapture = match.captures.find((c) => ["use", "require", "require_once", "include", "include_once"].includes(c.name));
+        const valueCapture = match.captures.find((c) => c.name === "name" || c.name === "path");
+        if (!stmtCapture || !valueCapture)
+            continue;
+        const stmtNode = stmtCapture.node;
+        const startPos = stmtNode.startPosition;
+        const endPos = stmtNode.endPosition;
+        const line = startPos.row + 1;
+        const col = startPos.column;
+        const isUse = stmtCapture.name === "use";
+        const specifier = valueCapture.node.text.replace(/^['"]|['"]$/g, "");
+        const localKey = (0, shared_js_1.buildImportLocalKey)(file.path, isUse ? "use" : "import", specifier, line, col);
+        if (seenImportKeys.has(localKey))
+            continue;
+        seenImportKeys.add(localKey);
+        semantics.imports.push({
+            localKey,
+            moduleSpecifier: specifier,
+            importKind: isUse ? "use" : "include",
+            isTypeOnly: false,
+            importedNames: [],
+            line,
+            col,
+            endLine: endPos.row + 1,
+            endCol: endPos.column,
+            resolutionKind: isUse ? "package" : "unresolved",
+            targetPathText: isUse ? null : specifier,
+            targetExternalSymbolKey: isUse ? `php:${specifier}` : null,
+        });
+        if (isUse) {
+            semantics.externalSymbols.push((0, shared_js_1.createExternalSymbolDraft)(projectImportId, file.language, specifier));
+        }
+    }
+    return semantics;
+}
+function parsePhpFileWithRegexFallback(file, projectImportId) {
+    const semantics = {
+        symbols: [],
+        imports: [],
+        exports: [],
+        relationships: [],
+        calls: [],
+        issues: [],
+        externalSymbols: [],
+    };
+    const lines = (file.content ?? "").split(/\r?\n/);
+    lines.forEach((line, index) => {
+        const lineNumber = index + 1;
+        const namespaceMatch = line.match(/^\s*namespace\s+([^;{]+)\s*[;{]/);
+        if (namespaceMatch?.[1]) {
+            const displayName = namespaceMatch[1].trim();
+            const col = line.indexOf(displayName);
+            semantics.symbols.push({
+                localKey: (0, shared_js_1.buildLocalSymbolKey)(file.path, "namespace", displayName),
+                stableKey: (0, shared_js_1.buildStableSymbolKey)(file.path, "namespace", displayName, lineNumber),
+                displayName,
+                kind: "namespace",
+                language: file.language,
+                signature: line.trim(),
+                returnType: null,
+                doc: null,
+                isExported: true,
+                isDefaultExport: false,
+                line: lineNumber,
+                col: Math.max(col, 0),
+                endLine: lineNumber,
+                endCol: Math.max(col, 0) + displayName.length,
+            });
+            return;
+        }
+        const useMatch = line.match(/^\s*use\s+([^;]+)\s*;/);
+        if (useMatch?.[1]) {
+            const moduleSpecifier = useMatch[1].trim();
+            const col = line.indexOf(moduleSpecifier);
+            semantics.imports.push({
+                localKey: (0, shared_js_1.buildImportLocalKey)(file.path, "use", moduleSpecifier, lineNumber, Math.max(col, 0)),
+                moduleSpecifier,
+                importKind: "use",
+                isTypeOnly: false,
+                importedNames: [moduleSpecifier.split("\\").pop() ?? moduleSpecifier],
+                line: lineNumber,
+                col: Math.max(col, 0),
+                endLine: lineNumber,
+                endCol: Math.max(col, 0) + moduleSpecifier.length,
+                resolutionKind: "package",
+                targetPathText: null,
+                targetExternalSymbolKey: `php:${moduleSpecifier}`,
+            });
+            semantics.externalSymbols.push((0, shared_js_1.createExternalSymbolDraft)(projectImportId, file.language, moduleSpecifier));
+            return;
+        }
+        const symbolMatch = line.match(/^\s*(class|interface|trait|enum|function)\s+([A-Za-z_][A-Za-z0-9_]*)/);
+        if (!symbolMatch?.[1] || !symbolMatch[2])
+            return;
+        const kind = symbolMatch[1];
+        const displayName = symbolMatch[2];
+        const col = line.indexOf(displayName);
+        semantics.symbols.push({
+            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: true,
+            isDefaultExport: false,
+            line: lineNumber,
+            col: Math.max(col, 0),
+            endLine: lineNumber,
+            endCol: Math.max(col, 0) + displayName.length,
+        });
+    });
+    return semantics;
+}

package/dist/parsers/python.d.ts

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

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

@@ -0,0 +1 @@
+{"version":3,"file":"python.d.ts","sourceRoot":"","sources":["../../src/parsers/python.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,sBAAsB,EAAE,MAAM,sBAAsB,CAAC;AAEnE,OAAO,EAAmB,KAAK,wBAAwB,EAAE,MAAM,YAAY,CAAC;AAqB5E,wBAAsB,eAAe,CACnC,IAAI,EAAE,sBAAsB,EAC5B,WAAW,EAAE,GAAG,CAAC,MAAM,CAAC,EACxB,eAAe,EAAE,MAAM,GACtB,OAAO,CAAC,wBAAwB,CAAC,CA4LnC"}

package/dist/parsers/python.js

@@ -0,0 +1,200 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parsePythonFile = parsePythonFile;
+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 getPythonParser() {
+    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-python/package.json")), "tree-sitter-python.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 parsePythonFile(file, filePathSet, projectImportId) {
+    const content = file.content ?? "";
+    if (!content.trim())
+        return { ...types_js_1.EMPTY_SEMANTICS };
+    let parser;
+    let language;
+    try {
+        ({ parser, language } = await getPythonParser());
+    }
+    catch {
+        return { ...types_js_1.EMPTY_SEMANTICS };
+    }
+    const tree = parser.parse(content);
+    if (!tree)
+        return { ...types_js_1.EMPTY_SEMANTICS };
+    const semantics = {
+        symbols: [],
+        imports: [],
+        exports: [],
+        relationships: [],
+        calls: [],
+        issues: [],
+        externalSymbols: [],
+    };
+    // Extract class and function/method definitions
+    const symbolQuery = new web_tree_sitter_1.Query(language, `
+    (class_definition name: (identifier) @name) @class
+    (function_definition name: (identifier) @name) @function
+  `);
+    for (const match of symbolQuery.matches(tree.rootNode)) {
+        const defCapture = match.captures.find((c) => c.name === "class" || c.name === "function");
+        const nameCapture = match.captures.find((c) => c.name === "name");
+        if (!defCapture || !nameCapture)
+            continue;
+        const isClass = defCapture.name === "class";
+        const displayName = nameCapture.node.text;
+        const startPos = defCapture.node.startPosition;
+        const endPos = defCapture.node.endPosition;
+        const line = startPos.row + 1;
+        const col = startPos.column;
+        const parentType = defCapture.node.parent?.type;
+        const grandparentType = defCapture.node.parent?.parent?.type;
+        const isMethod = !isClass && parentType === "block" && grandparentType === "class_definition";
+        const kind = isClass ? "class" : isMethod ? "method" : "function";
+        semantics.symbols.push({
+            localKey: (0, shared_js_1.buildLocalSymbolKey)(file.path, kind, displayName),
+            stableKey: (0, shared_js_1.buildStableSymbolKey)(file.path, kind, displayName, line),
+            displayName,
+            kind,
+            language: file.language,
+            signature: content.split("\n")[startPos.row]?.trim() ?? null,
+            returnType: null,
+            doc: null,
+            isExported: true,
+            isDefaultExport: false,
+            line,
+            col,
+            endLine: endPos.row + 1,
+            endCol: endPos.column,
+        });
+    }
+    // Extract imports: `import X` and `from X import Y`
+    const importQuery = new web_tree_sitter_1.Query(language, `
+    (import_statement) @stmt
+    (import_from_statement) @stmt
+  `);
+    const seenImportKeys = new Set();
+    for (const match of importQuery.matches(tree.rootNode)) {
+        const stmtCapture = match.captures.find((c) => c.name === "stmt");
+        if (!stmtCapture)
+            continue;
+        const stmtNode = stmtCapture.node;
+        const startPos = stmtNode.startPosition;
+        const endPos = stmtNode.endPosition;
+        const line = startPos.row + 1;
+        const col = startPos.column;
+        if (stmtNode.type === "import_statement") {
+            for (let i = 0; i < stmtNode.childCount; i++) {
+                const child = stmtNode.child(i);
+                if (!child || (child.type !== "dotted_name" && child.type !== "aliased_import"))
+                    continue;
+                const moduleNode = child.type === "aliased_import" ? child.child(0) : child;
+                if (!moduleNode)
+                    continue;
+                const moduleSpecifier = moduleNode.text;
+                const localKey = (0, shared_js_1.buildImportLocalKey)(file.path, "import", moduleSpecifier, line, col);
+                if (seenImportKeys.has(localKey))
+                    continue;
+                seenImportKeys.add(localKey);
+                semantics.imports.push({
+                    localKey,
+                    moduleSpecifier,
+                    importKind: "import",
+                    isTypeOnly: false,
+                    importedNames: [],
+                    line,
+                    col,
+                    endLine: endPos.row + 1,
+                    endCol: endPos.column,
+                    resolutionKind: "package",
+                    targetPathText: null,
+                    targetExternalSymbolKey: `python:${moduleSpecifier}`,
+                });
+                semantics.externalSymbols.push((0, shared_js_1.createExternalSymbolDraft)(projectImportId, file.language, moduleSpecifier));
+            }
+        }
+        else if (stmtNode.type === "import_from_statement") {
+            const moduleNameNode = stmtNode.childForFieldName("module_name");
+            if (!moduleNameNode)
+                continue;
+            const rawSpecifier = moduleNameNode.text;
+            const leadingDots = rawSpecifier.match(/^(\.+)/)?.[1] ?? "";
+            const isRelative = leadingDots.length > 0;
+            const importedNames = [];
+            for (let i = 0; i < stmtNode.childCount; i++) {
+                const child = stmtNode.child(i);
+                if (!child)
+                    continue;
+                if (child.type === "import_from_names" || child.type === "wildcard_import") {
+                    for (let j = 0; j < child.childCount; j++) {
+                        const nameNode = child.child(j);
+                        if (nameNode?.type === "identifier")
+                            importedNames.push(nameNode.text);
+                    }
+                }
+            }
+            let targetPathText = null;
+            let resolutionKind = "package";
+            if (isRelative) {
+                const levels = leadingDots.length;
+                const cleanSpecifier = rawSpecifier.replace(/^\.+/, "");
+                let baseDir = node_path_1.default.posix.dirname(file.path);
+                for (let i = 1; i < levels; i++)
+                    baseDir = node_path_1.default.posix.dirname(baseDir);
+                const candidate = cleanSpecifier
+                    ? `${baseDir}/${cleanSpecifier.replace(/\./g, "/")}`.replace(/\/+/g, "/")
+                    : baseDir;
+                const candidates = [`${candidate}.py`, `${candidate}/__init__.py`];
+                const resolved = candidates.find((c) => filePathSet.has(c));
+                targetPathText = resolved ?? `${candidate}.py`;
+                resolutionKind = resolved ? "relative_path" : "unresolved";
+            }
+            const localKey = (0, shared_js_1.buildImportLocalKey)(file.path, "import", rawSpecifier, line, col);
+            if (seenImportKeys.has(localKey))
+                continue;
+            seenImportKeys.add(localKey);
+            semantics.imports.push({
+                localKey,
+                moduleSpecifier: rawSpecifier,
+                importKind: "import",
+                isTypeOnly: false,
+                importedNames,
+                line,
+                col,
+                endLine: endPos.row + 1,
+                endCol: endPos.column,
+                resolutionKind,
+                targetPathText,
+                targetExternalSymbolKey: isRelative ? null : `python:${rawSpecifier}`,
+            });
+            if (!isRelative) {
+                semantics.externalSymbols.push((0, shared_js_1.createExternalSymbolDraft)(projectImportId, file.language, rawSpecifier));
+            }
+            else if (resolutionKind === "unresolved") {
+                semantics.issues.push({
+                    projectImportId,
+                    severity: "warning",
+                    code: "UNRESOLVED_IMPORT",
+                    message: `Unable to resolve import "${rawSpecifier}" from ${file.path}`,
+                    detailJson: { filePath: file.path, moduleSpecifier: rawSpecifier },
+                });
+            }
+        }
+    }
+    return semantics;
+}