project-librarian 0.4.0 → 0.4.1

package/dist/code-index/extractors/tree-sitter.js

@@ -0,0 +1,319 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.treeSitterBackends = treeSitterBackends;
+const shared_1 = require("./shared");
+const treeSitterGrammarPackages = {
+    "tree-sitter-c": "@sengac/tree-sitter-c",
+    "tree-sitter-cpp": "@sengac/tree-sitter-cpp",
+    "tree-sitter-csharp": "@sengac/tree-sitter-c-sharp",
+    "tree-sitter-go": "@sengac/tree-sitter-go",
+    "tree-sitter-java": "@sengac/tree-sitter-java",
+    "tree-sitter-javascript": "@sengac/tree-sitter-javascript",
+    "tree-sitter-kotlin": "@sengac/tree-sitter-kotlin",
+    "tree-sitter-php": "@sengac/tree-sitter-php",
+    "tree-sitter-python": "@sengac/tree-sitter-python",
+    "tree-sitter-rust": "@sengac/tree-sitter-rust",
+    "tree-sitter-swift": "@sengac/tree-sitter-swift",
+};
+function createTreeSitterParserResolver(fail) {
+    const treeSitterParsers = new Map();
+    function requireTreeSitterPackage(packageName) {
+        try {
+            return require(packageName);
+        }
+        catch (error) {
+            const message = error instanceof Error ? error.message : String(error);
+            fail(`--code-parser tree-sitter requires optional package ${packageName}; install project optional dependencies with npm install. Error: ${message}`);
+        }
+    }
+    function treeSitterGrammarForProfile(profile) {
+        if (profile === "tree-sitter-typescript" || profile === "tree-sitter-tsx") {
+            const grammars = requireTreeSitterPackage("@sengac/tree-sitter-typescript");
+            const grammar = profile === "tree-sitter-tsx" ? grammars.tsx : grammars.typescript;
+            if (!grammar)
+                fail(`tree-sitter-typescript did not expose the expected ${profile === "tree-sitter-tsx" ? "tsx" : "typescript"} grammar`);
+            return grammar;
+        }
+        const packageName = treeSitterGrammarPackages[profile];
+        if (packageName) {
+            const grammarModule = requireTreeSitterPackage(packageName);
+            const grammar = profile === "tree-sitter-php"
+                ? grammarModule.php ?? grammarModule.php_only
+                : grammarModule;
+            if (!grammar)
+                fail(`${packageName} did not expose a Tree-sitter grammar for ${profile}`);
+            return grammar;
+        }
+        fail(`missing Tree-sitter grammar for profile: ${profile}`);
+    }
+    return (profile) => {
+        const cached = treeSitterParsers.get(profile);
+        if (cached)
+            return cached;
+        const Parser = requireTreeSitterPackage("@sengac/tree-sitter");
+        const parser = new Parser();
+        parser.setLanguage(treeSitterGrammarForProfile(profile));
+        treeSitterParsers.set(profile, parser);
+        return parser;
+    };
+}
+function treeSitterLine(node) {
+    return node.startPosition.row + 1;
+}
+function treeSitterFieldText(node, fieldName) {
+    return node.childForFieldName(fieldName)?.text ?? "";
+}
+function treeSitterSignature(node) {
+    return (0, shared_1.oneLine)(node.text);
+}
+function unquoteLiteral(text) {
+    const trimmed = text.trim();
+    if (trimmed.length >= 2) {
+        const first = trimmed[0];
+        const last = trimmed[trimmed.length - 1];
+        if ((first === "\"" && last === "\"") || (first === "'" && last === "'") || (first === "`" && last === "`"))
+            return trimmed.slice(1, -1);
+    }
+    return trimmed;
+}
+function forEachNamedTreeSitterNode(node, visit) {
+    visit(node);
+    for (let index = 0; index < node.namedChildCount; index += 1) {
+        const child = node.namedChild(index);
+        if (child)
+            forEachNamedTreeSitterNode(child, visit);
+    }
+}
+function firstNamedChildOfType(node, type) {
+    for (let index = 0; index < node.namedChildCount; index += 1) {
+        const child = node.namedChild(index);
+        if (child?.type === type)
+            return child;
+    }
+    return null;
+}
+function treeSitterModuleSpecifier(node) {
+    const source = treeSitterFieldText(node, "source");
+    if (source)
+        return unquoteLiteral(source);
+    const raw = node.text;
+    return raw.match(/\bfrom\s*["'`]([^"'`]+)["'`]/)?.[1]
+        ?? raw.match(/^\s*import\s*["'`]([^"'`]+)["'`]/)?.[1]
+        ?? raw.match(/\brequire\s*\(\s*["'`]([^"'`]+)["'`]\s*\)/)?.[1]
+        ?? "";
+}
+function indexTreeSitterJavaScriptLike(file, statements, parserForProfile) {
+    const tree = parserForProfile(file.profile).parse(file.text);
+    function visit(node, context) {
+        let nextContext = context;
+        if (node.type === "function_declaration") {
+            const name = treeSitterFieldText(node, "name");
+            (0, shared_1.insertSymbol)(statements, name, "function", file, treeSitterLine(node), treeSitterSignature(node));
+            if (name)
+                nextContext = name;
+        }
+        else if (node.type === "class_declaration") {
+            const name = treeSitterFieldText(node, "name");
+            (0, shared_1.insertSymbol)(statements, name, "class", file, treeSitterLine(node), treeSitterSignature(node));
+            if (name)
+                nextContext = name;
+        }
+        else if (node.type === "method_definition" || node.type === "method_signature") {
+            const name = treeSitterFieldText(node, "name");
+            (0, shared_1.insertSymbol)(statements, name, "method", file, treeSitterLine(node), treeSitterSignature(node));
+            if (name)
+                nextContext = name;
+        }
+        else if (node.type === "interface_declaration") {
+            (0, shared_1.insertSymbol)(statements, treeSitterFieldText(node, "name"), "interface", file, treeSitterLine(node), treeSitterSignature(node));
+        }
+        else if (node.type === "type_alias_declaration") {
+            (0, shared_1.insertSymbol)(statements, treeSitterFieldText(node, "name"), "type", file, treeSitterLine(node), treeSitterSignature(node));
+        }
+        else if (node.type === "enum_declaration") {
+            (0, shared_1.insertSymbol)(statements, treeSitterFieldText(node, "name"), "enum", file, treeSitterLine(node), treeSitterSignature(node));
+        }
+        else if (node.type === "variable_declarator") {
+            const name = treeSitterFieldText(node, "name");
+            const valueType = node.childForFieldName("value")?.type ?? "";
+            const symbolKind = ["arrow_function", "function", "function_expression"].includes(valueType) ? "function" : "variable";
+            (0, shared_1.insertSymbol)(statements, name, symbolKind, file, treeSitterLine(node), treeSitterSignature(node));
+            if (symbolKind === "function" && name)
+                nextContext = name;
+        }
+        else if (node.type === "import_statement" || node.type === "export_statement") {
+            const toRef = treeSitterModuleSpecifier(node);
+            if (toRef) {
+                const imported = node.text.match(/^\s*import\s+(.+?)\s+from\s*["'`]/)?.[1] ?? node.text.match(/^\s*export\s+(.+?)\s+from\s*["'`]/)?.[1] ?? "";
+                statements.insertImport.run(file.path, toRef, (0, shared_1.oneLine)(imported), treeSitterLine(node), treeSitterSignature(node));
+                (0, shared_1.insertEdge)(statements, node.type === "export_statement" ? "export" : "import", "file", file.path, "module", toRef, file, treeSitterLine(node), treeSitterSignature(node));
+            }
+        }
+        else if (node.type === "call_expression") {
+            const raw = node.text;
+            const routeMatch = raw.match(/^(?:app|router|server)\.(get|post|put|patch|delete|all)\s*\(\s*["'`]([^"'`]+)["'`]\s*,\s*([^,)]+)/);
+            if (routeMatch) {
+                const method = (routeMatch[1] ?? "").toUpperCase();
+                const route = routeMatch[2] ?? "";
+                const handler = (0, shared_1.oneLine)(routeMatch[3] ?? "");
+                statements.insertRoute.run(method, route, file.path, treeSitterLine(node), handler);
+                (0, shared_1.insertEdge)(statements, "route_to_handler", "route", `${method} ${route}`, "symbol", handler, file, treeSitterLine(node), treeSitterSignature(node));
+            }
+            const requireRef = treeSitterModuleSpecifier(node);
+            if (requireRef) {
+                statements.insertImport.run(file.path, requireRef, "", treeSitterLine(node), treeSitterSignature(node));
+                (0, shared_1.insertEdge)(statements, "import", "file", file.path, "module", requireRef, file, treeSitterLine(node), treeSitterSignature(node));
+            }
+            else {
+                const target = treeSitterFieldText(node, "function");
+                (0, shared_1.insertEdge)(statements, "call", context ? "symbol" : "file", context || file.path, "symbol", target, file, treeSitterLine(node), treeSitterSignature(node));
+            }
+        }
+        for (let index = 0; index < node.namedChildCount; index += 1) {
+            const child = node.namedChild(index);
+            if (child)
+                visit(child, nextContext);
+        }
+    }
+    visit(tree.rootNode, "");
+}
+function indexTreeSitterPython(file, statements, parserForProfile) {
+    const tree = parserForProfile(file.profile).parse(file.text);
+    forEachNamedTreeSitterNode(tree.rootNode, (node) => {
+        if (node.type === "function_definition") {
+            const name = treeSitterFieldText(node, "name");
+            (0, shared_1.insertSymbol)(statements, name, "function", file, treeSitterLine(node), treeSitterSignature(node));
+        }
+        else if (node.type === "class_definition") {
+            const name = treeSitterFieldText(node, "name");
+            (0, shared_1.insertSymbol)(statements, name, "class", file, treeSitterLine(node), treeSitterSignature(node));
+        }
+        else if (node.type === "import_statement" || node.type === "import_from_statement") {
+            const raw = node.text.trim();
+            const fromMatch = raw.match(/^from\s+([A-Za-z0-9_.$]+)\s+import\s+(.+)$/);
+            const importMatch = raw.match(/^import\s+(.+)$/);
+            const toRef = fromMatch?.[1] ?? importMatch?.[1] ?? "";
+            const imported = fromMatch?.[2] ?? "";
+            if (toRef) {
+                statements.insertImport.run(file.path, toRef, imported.trim(), treeSitterLine(node), raw);
+                (0, shared_1.insertEdge)(statements, "import", "file", file.path, "module", toRef, file, treeSitterLine(node), raw);
+            }
+        }
+    });
+}
+function indexTreeSitterGo(file, statements, parserForProfile) {
+    const tree = parserForProfile(file.profile).parse(file.text);
+    forEachNamedTreeSitterNode(tree.rootNode, (node) => {
+        if (node.type === "function_declaration") {
+            const name = treeSitterFieldText(node, "name");
+            (0, shared_1.insertSymbol)(statements, name, "function", file, treeSitterLine(node), treeSitterSignature(node));
+        }
+        else if (node.type === "method_declaration") {
+            const name = treeSitterFieldText(node, "name");
+            (0, shared_1.insertSymbol)(statements, name, "method", file, treeSitterLine(node), treeSitterSignature(node));
+        }
+        else if (node.type === "type_declaration") {
+            const spec = firstNamedChildOfType(node, "type_spec");
+            const name = spec ? treeSitterFieldText(spec, "name") : "";
+            (0, shared_1.insertSymbol)(statements, name, "type", file, treeSitterLine(node), treeSitterSignature(node));
+        }
+        else if (node.type === "const_declaration" || node.type === "var_declaration") {
+            const spec = firstNamedChildOfType(node, node.type === "const_declaration" ? "const_spec" : "var_spec");
+            const name = spec ? treeSitterFieldText(spec, "name") : "";
+            (0, shared_1.insertSymbol)(statements, name, node.type === "const_declaration" ? "constant" : "variable", file, treeSitterLine(node), treeSitterSignature(node));
+        }
+        else if (node.type === "import_spec") {
+            const toRef = unquoteLiteral(treeSitterFieldText(node, "path") || (node.text.match(/"([^"]+)"/)?.[1] ?? ""));
+            const imported = treeSitterFieldText(node, "name");
+            (0, shared_1.insertGoImport)(file, statements, toRef, imported, treeSitterLine(node), treeSitterSignature(node));
+        }
+    });
+}
+function treeSitterGenericLanguage(file, fail) {
+    const normalized = file.profile.replace(/^tree-sitter-/, "");
+    if (["c", "cpp", "csharp", "java", "kotlin", "php", "rust", "swift"].includes(normalized))
+        return normalized;
+    fail(`unsupported generic Tree-sitter profile: ${file.profile}`);
+}
+function symbolNameFromPatterns(text, patterns) {
+    for (const pattern of patterns) {
+        const match = text.match(pattern);
+        if (match?.[1])
+            return match[1];
+    }
+    return "";
+}
+function treeSitterGenericSymbol(node, language) {
+    const raw = node.text;
+    const fieldName = treeSitterFieldText(node, "name");
+    const patterns = {
+        c: [[["function_definition"], "function", [/\b([A-Za-z_]\w*)\s*\([^;{}]*\)\s*\{/]], [["struct_specifier"], "struct", [/\bstruct\s+([A-Za-z_]\w*)/]], [["enum_specifier"], "enum", [/\benum\s+([A-Za-z_]\w*)/]]],
+        cpp: [[["function_definition"], "function", [/\b([A-Za-z_]\w*)\s*\([^;{}]*\)\s*(?:const\s*)?\{/]], [["class_specifier"], "class", [/\bclass\s+([A-Za-z_]\w*)/, /\bstruct\s+([A-Za-z_]\w*)/]], [["namespace_definition"], "namespace", [/\bnamespace\s+([A-Za-z_]\w*)/]], [["enum_specifier"], "enum", [/\benum(?:\s+class)?\s+([A-Za-z_]\w*)/]]],
+        csharp: [[["method_declaration", "constructor_declaration"], "method", [/\b([A-Za-z_]\w*)\s*\(/]], [["class_declaration"], "class", [/\bclass\s+([A-Za-z_]\w*)/]], [["interface_declaration"], "interface", [/\binterface\s+([A-Za-z_]\w*)/]], [["struct_declaration"], "struct", [/\bstruct\s+([A-Za-z_]\w*)/]], [["enum_declaration"], "enum", [/\benum\s+([A-Za-z_]\w*)/]]],
+        java: [[["method_declaration", "constructor_declaration"], "method", [/\b([A-Za-z_]\w*)\s*\(/]], [["class_declaration"], "class", [/\bclass\s+([A-Za-z_]\w*)/]], [["interface_declaration"], "interface", [/\binterface\s+([A-Za-z_]\w*)/]], [["enum_declaration"], "enum", [/\benum\s+([A-Za-z_]\w*)/]]],
+        kotlin: [[["function_declaration"], "function", [/\bfun\s+([A-Za-z_]\w*)/]], [["class_declaration"], "class", [/\bclass\s+([A-Za-z_]\w*)/, /\binterface\s+([A-Za-z_]\w*)/]], [["object_declaration"], "object", [/\bobject\s+([A-Za-z_]\w*)/]]],
+        php: [[["function_definition"], "function", [/\bfunction\s+([A-Za-z_]\w*)/]], [["method_declaration"], "method", [/\bfunction\s+([A-Za-z_]\w*)/]], [["class_declaration"], "class", [/\bclass\s+([A-Za-z_]\w*)/]], [["interface_declaration"], "interface", [/\binterface\s+([A-Za-z_]\w*)/]], [["trait_declaration"], "trait", [/\btrait\s+([A-Za-z_]\w*)/]]],
+        rust: [[["function_item"], "function", [/\bfn\s+([A-Za-z_]\w*)/]], [["struct_item"], "struct", [/\bstruct\s+([A-Za-z_]\w*)/]], [["enum_item"], "enum", [/\benum\s+([A-Za-z_]\w*)/]], [["trait_item"], "trait", [/\btrait\s+([A-Za-z_]\w*)/]], [["impl_item"], "impl", [/\bimpl(?:\s*<[^>]+>)?\s+([A-Za-z_]\w*)/]]],
+        swift: [[["function_declaration"], "function", [/\bfunc\s+([A-Za-z_]\w*)/]], [["class_declaration"], "class", [/\bclass\s+([A-Za-z_]\w*)/]], [["struct_declaration"], "struct", [/\bstruct\s+([A-Za-z_]\w*)/]], [["protocol_declaration"], "protocol", [/\bprotocol\s+([A-Za-z_]\w*)/]], [["enum_declaration"], "enum", [/\benum\s+([A-Za-z_]\w*)/]]],
+    };
+    for (const [types, kind, regexes] of patterns[language] ?? []) {
+        if (!types.includes(node.type))
+            continue;
+        const name = fieldName || symbolNameFromPatterns(raw, regexes);
+        return name ? { kind, name } : null;
+    }
+    return null;
+}
+function treeSitterGenericImport(node, language) {
+    const raw = node.text.trim();
+    const importTypes = {
+        c: ["preproc_include"],
+        cpp: ["preproc_include", "using_declaration", "namespace_alias_definition"],
+        csharp: ["using_directive"],
+        java: ["import_declaration"],
+        kotlin: ["import_header"],
+        php: ["namespace_use_declaration"],
+        rust: ["use_declaration"],
+        swift: ["import_declaration"],
+    };
+    if (!(importTypes[language] ?? []).includes(node.type))
+        return null;
+    const toRef = raw.match(/#include\s*[<"]([^>"]+)[>"]/)?.[1]
+        ?? raw.match(/\bimport\s+([A-Za-z0-9_.*.$\\/-]+)/)?.[1]
+        ?? raw.match(/\busing\s+([A-Za-z0-9_.*.$\\/-]+)/)?.[1]
+        ?? raw.match(/\buse\s+([A-Za-z0-9_:{}*,\s]+);?/)?.[1]?.replace(/\s+/g, " ").trim()
+        ?? "";
+    return toRef ? { imported: "", kind: language === "rust" ? "use" : "import", toRef } : null;
+}
+function indexTreeSitterGeneric(file, statements, parserForProfile, fail) {
+    const language = treeSitterGenericLanguage(file, fail);
+    const tree = parserForProfile(file.profile).parse(file.text);
+    forEachNamedTreeSitterNode(tree.rootNode, (node) => {
+        const symbol = treeSitterGenericSymbol(node, language);
+        if (symbol)
+            (0, shared_1.insertSymbol)(statements, symbol.name, symbol.kind, file, treeSitterLine(node), treeSitterSignature(node));
+        const imported = treeSitterGenericImport(node, language);
+        if (imported) {
+            statements.insertImport.run(file.path, imported.toRef, imported.imported, treeSitterLine(node), treeSitterSignature(node));
+            (0, shared_1.insertEdge)(statements, imported.kind, "file", file.path, "module", imported.toRef, file, treeSitterLine(node), treeSitterSignature(node));
+        }
+    });
+}
+function treeSitterBackends(fail) {
+    const parserForProfile = createTreeSitterParserResolver(fail);
+    return [
+        { id: "tree-sitter-javascript", index: (file, statements) => indexTreeSitterJavaScriptLike(file, statements, parserForProfile), label: "Tree-sitter JavaScript grammar", profile: "tree-sitter-javascript", strength: "structural" },
+        { id: "tree-sitter-typescript", index: (file, statements) => indexTreeSitterJavaScriptLike(file, statements, parserForProfile), label: "Tree-sitter TypeScript grammar", profile: "tree-sitter-typescript", strength: "structural" },
+        { id: "tree-sitter-typescript", index: (file, statements) => indexTreeSitterJavaScriptLike(file, statements, parserForProfile), label: "Tree-sitter TSX grammar", profile: "tree-sitter-tsx", strength: "structural" },
+        { id: "tree-sitter-python", index: (file, statements) => indexTreeSitterPython(file, statements, parserForProfile), label: "Tree-sitter Python grammar", profile: "tree-sitter-python", strength: "structural" },
+        { id: "tree-sitter-go", index: (file, statements) => indexTreeSitterGo(file, statements, parserForProfile), label: "Tree-sitter Go grammar", profile: "tree-sitter-go", strength: "structural" },
+        { id: "tree-sitter-c", index: (file, statements) => indexTreeSitterGeneric(file, statements, parserForProfile, fail), label: "Tree-sitter C grammar", profile: "tree-sitter-c", strength: "structural" },
+        { id: "tree-sitter-cpp", index: (file, statements) => indexTreeSitterGeneric(file, statements, parserForProfile, fail), label: "Tree-sitter C++ grammar", profile: "tree-sitter-cpp", strength: "structural" },
+        { id: "tree-sitter-csharp", index: (file, statements) => indexTreeSitterGeneric(file, statements, parserForProfile, fail), label: "Tree-sitter C# grammar", profile: "tree-sitter-csharp", strength: "structural" },
+        { id: "tree-sitter-java", index: (file, statements) => indexTreeSitterGeneric(file, statements, parserForProfile, fail), label: "Tree-sitter Java grammar", profile: "tree-sitter-java", strength: "structural" },
+        { id: "tree-sitter-kotlin", index: (file, statements) => indexTreeSitterGeneric(file, statements, parserForProfile, fail), label: "Tree-sitter Kotlin grammar", profile: "tree-sitter-kotlin", strength: "structural" },
+        { id: "tree-sitter-php", index: (file, statements) => indexTreeSitterGeneric(file, statements, parserForProfile, fail), label: "Tree-sitter PHP grammar", profile: "tree-sitter-php", strength: "structural" },
+        { id: "tree-sitter-rust", index: (file, statements) => indexTreeSitterGeneric(file, statements, parserForProfile, fail), label: "Tree-sitter Rust grammar", profile: "tree-sitter-rust", strength: "structural" },
+        { id: "tree-sitter-swift", index: (file, statements) => indexTreeSitterGeneric(file, statements, parserForProfile, fail), label: "Tree-sitter Swift grammar", profile: "tree-sitter-swift", strength: "structural" },
+    ];
+}

package/dist/code-index/extractors/types.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/code-index/extractors/typescript.js

@@ -0,0 +1,211 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.indexJavaScriptLike = indexJavaScriptLike;
+const path = __importStar(require("node:path"));
+const ts = __importStar(require("typescript"));
+const shared_1 = require("./shared");
+const httpMethods = new Set(["all", "delete", "get", "patch", "post", "put"]);
+function scriptKindForPath(relativePath) {
+    const extension = path.extname(relativePath).toLowerCase();
+    if (extension === ".tsx")
+        return ts.ScriptKind.TSX;
+    if (extension === ".jsx")
+        return ts.ScriptKind.JSX;
+    if ([".ts", ".mts", ".cts"].includes(extension))
+        return ts.ScriptKind.TS;
+    return ts.ScriptKind.JS;
+}
+function tsLine(sourceFile, node) {
+    return sourceFile.getLineAndCharacterOfPosition(node.getStart(sourceFile)).line + 1;
+}
+function nodeName(node, sourceFile) {
+    if (ts.isIdentifier(node))
+        return node.text;
+    if (ts.isStringLiteral(node) || ts.isNumericLiteral(node))
+        return node.text;
+    if (ts.isPrivateIdentifier(node))
+        return node.text;
+    return (0, shared_1.oneLine)(node.getText(sourceFile));
+}
+function propertyNameText(name, sourceFile) {
+    if (!name)
+        return "";
+    return nodeName(name, sourceFile);
+}
+function callTarget(expression, sourceFile) {
+    if (ts.isIdentifier(expression))
+        return expression.text;
+    if (ts.isPropertyAccessExpression(expression))
+        return (0, shared_1.oneLine)(expression.getText(sourceFile));
+    if (ts.isElementAccessExpression(expression))
+        return (0, shared_1.oneLine)(expression.getText(sourceFile));
+    return (0, shared_1.oneLine)(expression.getText(sourceFile));
+}
+function importBindingText(importClause, sourceFile) {
+    if (!importClause)
+        return "";
+    const names = [];
+    if (importClause.name)
+        names.push(importClause.name.text);
+    const namedBindings = importClause.namedBindings;
+    if (namedBindings && ts.isNamespaceImport(namedBindings))
+        names.push(`* as ${namedBindings.name.text}`);
+    if (namedBindings && ts.isNamedImports(namedBindings)) {
+        for (const element of namedBindings.elements)
+            names.push(element.name.text);
+    }
+    return names.join(", ") || (0, shared_1.oneLine)(importClause.getText(sourceFile));
+}
+function stringArg(node) {
+    if (!node)
+        return "";
+    return ts.isStringLiteral(node) || ts.isNoSubstitutionTemplateLiteral(node) ? node.text : "";
+}
+function handlerArg(node, sourceFile) {
+    if (!node)
+        return "";
+    return callTarget(node, sourceFile);
+}
+function routeFromCall(node, sourceFile) {
+    if (!ts.isPropertyAccessExpression(node.expression))
+        return null;
+    const method = node.expression.name.text.toLowerCase();
+    if (!httpMethods.has(method))
+        return null;
+    const receiver = node.expression.expression;
+    if (!ts.isIdentifier(receiver) || !["app", "router", "server"].includes(receiver.text))
+        return null;
+    const route = stringArg(node.arguments[0]);
+    if (!route)
+        return null;
+    return {
+        handler: handlerArg(node.arguments[1], sourceFile),
+        method: method.toUpperCase(),
+        route,
+    };
+}
+function routeFromDecorator(node, sourceFile) {
+    const decorators = ts.canHaveDecorators(node) ? ts.getDecorators(node) ?? [] : [];
+    const routes = [];
+    for (const decorator of decorators) {
+        const expression = decorator.expression;
+        if (!ts.isCallExpression(expression))
+            continue;
+        const callee = expression.expression;
+        if (!ts.isIdentifier(callee))
+            continue;
+        const method = callee.text.toLowerCase();
+        if (!httpMethods.has(method))
+            continue;
+        routes.push({ method: method.toUpperCase(), route: stringArg(expression.arguments[0]) || "/" });
+    }
+    return routes;
+}
+function signatureFor(node, sourceFile) {
+    return (0, shared_1.oneLine)(node.getText(sourceFile));
+}
+function indexJavaScriptLike(file, statements) {
+    const sourceFile = ts.createSourceFile(file.path, file.text, ts.ScriptTarget.Latest, true, scriptKindForPath(file.path));
+    function visit(node, context) {
+        let nextContext = context;
+        if (ts.isFunctionDeclaration(node)) {
+            const name = node.name?.text ?? "";
+            (0, shared_1.insertSymbol)(statements, name, "function", file, tsLine(sourceFile, node), signatureFor(node, sourceFile));
+            if (name)
+                nextContext = name;
+        }
+        else if (ts.isClassDeclaration(node)) {
+            const name = node.name?.text ?? "";
+            (0, shared_1.insertSymbol)(statements, name, "class", file, tsLine(sourceFile, node), signatureFor(node, sourceFile));
+            if (name)
+                nextContext = name;
+        }
+        else if (ts.isInterfaceDeclaration(node)) {
+            (0, shared_1.insertSymbol)(statements, node.name.text, "interface", file, tsLine(sourceFile, node), signatureFor(node, sourceFile));
+        }
+        else if (ts.isTypeAliasDeclaration(node)) {
+            (0, shared_1.insertSymbol)(statements, node.name.text, "type", file, tsLine(sourceFile, node), signatureFor(node, sourceFile));
+        }
+        else if (ts.isEnumDeclaration(node)) {
+            (0, shared_1.insertSymbol)(statements, node.name.text, "enum", file, tsLine(sourceFile, node), signatureFor(node, sourceFile));
+        }
+        else if (ts.isMethodDeclaration(node)) {
+            const name = propertyNameText(node.name, sourceFile);
+            (0, shared_1.insertSymbol)(statements, name, "method", file, tsLine(sourceFile, node), signatureFor(node, sourceFile));
+            for (const route of routeFromDecorator(node, sourceFile)) {
+                statements.insertRoute.run(route.method, route.route, file.path, tsLine(sourceFile, node), name);
+                (0, shared_1.insertEdge)(statements, "route_to_handler", "route", `${route.method} ${route.route}`, "symbol", name, file, tsLine(sourceFile, node), signatureFor(node, sourceFile));
+            }
+            if (name)
+                nextContext = name;
+        }
+        else if (ts.isVariableDeclaration(node) && ts.isIdentifier(node.name)) {
+            const symbolKind = node.initializer && (ts.isArrowFunction(node.initializer) || ts.isFunctionExpression(node.initializer)) ? "function" : "variable";
+            (0, shared_1.insertSymbol)(statements, node.name.text, symbolKind, file, tsLine(sourceFile, node), signatureFor(node, sourceFile));
+            if (symbolKind === "function")
+                nextContext = node.name.text;
+        }
+        else if (ts.isImportDeclaration(node) && ts.isStringLiteral(node.moduleSpecifier)) {
+            const imported = importBindingText(node.importClause, sourceFile);
+            statements.insertImport.run(file.path, node.moduleSpecifier.text, imported, tsLine(sourceFile, node), signatureFor(node, sourceFile));
+            (0, shared_1.insertEdge)(statements, "import", "file", file.path, "module", node.moduleSpecifier.text, file, tsLine(sourceFile, node), signatureFor(node, sourceFile));
+        }
+        else if (ts.isExportDeclaration(node) && node.moduleSpecifier && ts.isStringLiteral(node.moduleSpecifier)) {
+            const exported = node.exportClause ? (0, shared_1.oneLine)(node.exportClause.getText(sourceFile)) : "";
+            statements.insertImport.run(file.path, node.moduleSpecifier.text, exported, tsLine(sourceFile, node), signatureFor(node, sourceFile));
+            (0, shared_1.insertEdge)(statements, "export", "file", file.path, "module", node.moduleSpecifier.text, file, tsLine(sourceFile, node), signatureFor(node, sourceFile));
+        }
+        else if (ts.isCallExpression(node)) {
+            const route = routeFromCall(node, sourceFile);
+            if (route) {
+                statements.insertRoute.run(route.method, route.route, file.path, tsLine(sourceFile, node), route.handler);
+                (0, shared_1.insertEdge)(statements, "route_to_handler", "route", `${route.method} ${route.route}`, "symbol", route.handler, file, tsLine(sourceFile, node), signatureFor(node, sourceFile));
+            }
+            if (ts.isIdentifier(node.expression) && node.expression.text === "require") {
+                const moduleName = stringArg(node.arguments[0]);
+                if (moduleName) {
+                    statements.insertImport.run(file.path, moduleName, "", tsLine(sourceFile, node), signatureFor(node, sourceFile));
+                    (0, shared_1.insertEdge)(statements, "import", "file", file.path, "module", moduleName, file, tsLine(sourceFile, node), signatureFor(node, sourceFile));
+                }
+            }
+            else {
+                (0, shared_1.insertEdge)(statements, "call", context ? "symbol" : "file", context || file.path, "symbol", callTarget(node.expression, sourceFile), file, tsLine(sourceFile, node), signatureFor(node, sourceFile));
+            }
+        }
+        ts.forEachChild(node, (child) => visit(child, nextContext));
+    }
+    visit(sourceFile, "");
+}

package/dist/code-index/incremental.js

@@ -0,0 +1,16 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.planIndexUpdate = planIndexUpdate;
+function planIndexUpdate(currentFiles, indexedHashes) {
+    const currentByPath = new Map(currentFiles.map((file) => [file.path, file]));
+    const deletedPaths = Array.from(indexedHashes.keys()).filter((filePath) => !currentByPath.has(filePath));
+    const reindexedFiles = currentFiles.filter((file) => indexedHashes.get(file.path) !== file.hash);
+    return {
+        addedFiles: reindexedFiles.filter((file) => !indexedHashes.has(file.path)),
+        changedFiles: reindexedFiles.filter((file) => indexedHashes.has(file.path)),
+        currentByPath,
+        deletedPaths,
+        reindexedFiles,
+        unchangedFiles: currentFiles.length - reindexedFiles.length,
+    };
+}