project-librarian 0.3.0 → 0.4.1

package/dist/code-index/extractors/light-languages.js

@@ -0,0 +1,52 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.indexPythonLight = indexPythonLight;
+exports.indexGoLight = indexGoLight;
+const shared_1 = require("./shared");
+function indexPythonLight(file, statements) {
+    const symbolPatterns = [
+        [/^\s*def\s+([A-Za-z_]\w*)\s*\(([^)]*)\)/gm, "function", (match) => `def ${match[1] ?? ""}(${match[2] ?? ""})`],
+        [/^\s*class\s+([A-Za-z_]\w*)/gm, "class", (match) => `class ${match[1] ?? ""}`],
+    ];
+    for (const [regex, kind, signature] of symbolPatterns) {
+        (0, shared_1.insertMatches)(file, regex, (match, line) => (0, shared_1.insertSymbol)(statements, match[1] ?? "", kind, file, line, signature(match)));
+    }
+    const importPatterns = [
+        [/^\s*from\s+([A-Za-z0-9_.$]+)\s+import\s+(.+)$/gm, (match) => [match[1] ?? "", match[2] ?? ""]],
+        [/^\s*import\s+([A-Za-z0-9_.$, \t]+)$/gm, (match) => [match[1] ?? "", ""]],
+    ];
+    for (const [regex, fields] of importPatterns) {
+        (0, shared_1.insertMatches)(file, regex, (match, line) => {
+            const [toRef, imported] = fields(match);
+            statements.insertImport.run(file.path, toRef, imported.trim(), line, match[0].trim());
+            (0, shared_1.insertEdge)(statements, "import", "file", file.path, "module", toRef, file, line, match[0].trim());
+        });
+    }
+}
+function indexGoLight(file, statements) {
+    const symbolPatterns = [
+        [/^\s*func\s*\(\s*[^)]*\)\s*([A-Za-z_]\w*)\s*\(([^)]*)\)/gm, "method", (match) => match[1] ?? "", (match) => `func (...) ${match[1] ?? ""}(${match[2] ?? ""})`],
+        [/^\s*func\s+([A-Za-z_]\w*)\s*\(([^)]*)\)/gm, "function", (match) => match[1] ?? "", (match) => `func ${match[1] ?? ""}(${match[2] ?? ""})`],
+        [/^\s*type\s+([A-Za-z_]\w*)\s+(struct|interface)?/gm, "type", (match) => match[1] ?? "", (match) => `type ${match[1] ?? ""} ${match[2] ?? ""}`.trim()],
+        [/^\s*const\s+([A-Za-z_]\w*)\b/gm, "constant", (match) => match[1] ?? "", (match) => `const ${match[1] ?? ""}`],
+        [/^\s*var\s+([A-Za-z_]\w*)\b/gm, "variable", (match) => match[1] ?? "", (match) => `var ${match[1] ?? ""}`],
+    ];
+    for (const [regex, kind, name, signature] of symbolPatterns) {
+        (0, shared_1.insertMatches)(file, regex, (match, line) => (0, shared_1.insertSymbol)(statements, name(match), kind, file, line, signature(match)));
+    }
+    (0, shared_1.insertMatches)(file, /^\s*import\s+(?:(?:([A-Za-z_]\w*|[_.])\s+)?\"([^\"]+)\"|`([^`]+)`)/gm, (match, line) => {
+        const imported = match[1] ?? "";
+        const toRef = match[2] ?? match[3] ?? "";
+        (0, shared_1.insertGoImport)(file, statements, toRef, imported, line, match[0].trim());
+    });
+    (0, shared_1.insertMatches)(file, /^\s*import\s*\(([\s\S]*?)^\s*\)/gm, (blockMatch) => {
+        const block = blockMatch[1] ?? "";
+        const blockStart = blockMatch.index ?? 0;
+        for (const lineMatch of block.matchAll(/^\s*(?:([A-Za-z_]\w*|[_.])\s+)?\"([^\"]+)\"/gm)) {
+            const imported = lineMatch[1] ?? "";
+            const toRef = lineMatch[2] ?? "";
+            const line = (0, shared_1.lineNumber)(file.text, blockStart + (lineMatch.index ?? 0));
+            (0, shared_1.insertGoImport)(file, statements, toRef, imported, line, lineMatch[0].trim());
+        }
+    });
+}

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

@@ -0,0 +1,137 @@
+"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.extractionProfile = extractionProfile;
+exports.createExtractionBackendRegistry = createExtractionBackendRegistry;
+const path = __importStar(require("node:path"));
+const config_1 = require("./config");
+const light_languages_1 = require("./light-languages");
+const tree_sitter_1 = require("./tree-sitter");
+const typescript_1 = require("./typescript");
+function treeSitterProfile(relativePath) {
+    const extension = path.extname(relativePath).toLowerCase();
+    if ([".ts", ".mts", ".cts"].includes(extension))
+        return "tree-sitter-typescript";
+    if (extension === ".tsx")
+        return "tree-sitter-tsx";
+    if ([".js", ".mjs", ".cjs", ".jsx"].includes(extension))
+        return "tree-sitter-javascript";
+    if (extension === ".py")
+        return "tree-sitter-python";
+    if (extension === ".go")
+        return "tree-sitter-go";
+    if ([".c", ".h"].includes(extension))
+        return "tree-sitter-c";
+    if ([".cc", ".cpp", ".cxx", ".hpp", ".hh", ".hxx"].includes(extension))
+        return "tree-sitter-cpp";
+    if (extension === ".cs")
+        return "tree-sitter-csharp";
+    if (extension === ".java")
+        return "tree-sitter-java";
+    if ([".kt", ".kts"].includes(extension))
+        return "tree-sitter-kotlin";
+    if (extension === ".php")
+        return "tree-sitter-php";
+    if (extension === ".rs")
+        return "tree-sitter-rust";
+    if (extension === ".swift")
+        return "tree-sitter-swift";
+    return "inventory-only";
+}
+function extractionProfile(relativePath, language, parserMode) {
+    if (language === "config")
+        return "config";
+    if (parserMode === "tree-sitter")
+        return treeSitterProfile(relativePath);
+    if (isJavaScriptLikeProfileInput(language))
+        return "typescript-ast";
+    if (language === "python")
+        return "python-light";
+    if (language === "go")
+        return "go-light";
+    return "inventory-only";
+}
+function isJavaScriptLikeProfileInput(language) {
+    return language === "javascript" || language === "typescript";
+}
+function createExtractionBackendRegistry(fail) {
+    const extractionBackends = [
+        {
+            id: "typescript-compiler",
+            index: typescript_1.indexJavaScriptLike,
+            label: "TypeScript compiler API",
+            profile: "typescript-ast",
+            strength: "structural",
+        },
+        {
+            id: "regex-light",
+            index: light_languages_1.indexPythonLight,
+            label: "Python lightweight regex",
+            profile: "python-light",
+            strength: "light",
+        },
+        {
+            id: "regex-light",
+            index: light_languages_1.indexGoLight,
+            label: "Go lightweight regex",
+            profile: "go-light",
+            strength: "light",
+        },
+        ...(0, tree_sitter_1.treeSitterBackends)(fail),
+        {
+            id: "config-key-value",
+            index: (file, statements) => (0, config_1.indexConfigs)(file, statements.insertConfig),
+            label: "Configuration key/value extractor",
+            profile: "config",
+            strength: "config",
+        },
+        {
+            id: "inventory-only",
+            index: () => undefined,
+            label: "Inventory-only file listing",
+            profile: "inventory-only",
+            strength: "inventory",
+        },
+    ];
+    const extractionBackendsByProfile = new Map(extractionBackends.map((backend) => [backend.profile, backend]));
+    return {
+        backendForProfile(profile) {
+            const backend = extractionBackendsByProfile.get(profile);
+            if (!backend)
+                fail(`missing extraction backend for profile: ${profile}`);
+            return backend;
+        },
+    };
+}

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

@@ -0,0 +1,36 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.oneLine = oneLine;
+exports.lineNumber = lineNumber;
+exports.insertSymbol = insertSymbol;
+exports.insertEdge = insertEdge;
+exports.insertMatches = insertMatches;
+exports.insertGoImport = insertGoImport;
+function oneLine(text) {
+    return text.replace(/\s+/g, " ").trim().slice(0, 240);
+}
+function lineNumber(text, index) {
+    return text.slice(0, index).split(/\r?\n/).length;
+}
+function insertSymbol(statements, name, kind, file, line, signature) {
+    if (!name)
+        return;
+    statements.insertSymbol.run(name, kind, file.path, line, signature);
+    statements.insertSymbolFts.run(name, kind, file.path, signature);
+}
+function insertEdge(statements, kind, sourceKind, source, targetKind, target, file, line, evidence) {
+    if (!target)
+        return;
+    statements.insertEdge.run(kind, sourceKind, source, targetKind, target, file.path, line, evidence);
+}
+function insertMatches(file, regex, insert) {
+    for (const match of file.text.matchAll(regex)) {
+        insert(match, lineNumber(file.text, match.index ?? 0));
+    }
+}
+function insertGoImport(file, statements, toRef, imported, line, raw) {
+    if (!toRef)
+        return;
+    statements.insertImport.run(file.path, toRef, imported, line, raw);
+    insertEdge(statements, "import", "file", file.path, "module", toRef, file, line, raw);
+}

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 });