project-librarian 0.3.0 → 0.4.1

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,
+    };
+}

package/dist/code-index/index-health.js

@@ -0,0 +1,164 @@
+"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.inspectCodeIndexHealth = inspectCodeIndexHealth;
+exports.formatCodeIndexHealthRemediation = formatCodeIndexHealthRemediation;
+const fs = __importStar(require("node:fs"));
+function safeDiscoverCodeFiles(discoverCodeFiles, scopes) {
+    try {
+        return discoverCodeFiles(scopes).length;
+    }
+    catch {
+        return null;
+    }
+}
+function safeScalar(database, sql, param) {
+    try {
+        const rows = typeof param === "string" ? database.prepare(sql).all(param) : database.prepare(sql).all();
+        const value = rows[0]?.value;
+        return typeof value === "string" || typeof value === "number" ? String(value) : "";
+    }
+    catch {
+        return "";
+    }
+}
+function tableNames(database) {
+    try {
+        return database.prepare("SELECT name AS value FROM sqlite_schema WHERE type IN ('table', 'view') ORDER BY name")
+            .all()
+            .map((row) => String(row.value))
+            .filter(Boolean);
+    }
+    catch {
+        return [];
+    }
+}
+function readScopes(scopesJson, scopesText, fallback) {
+    if (scopesJson) {
+        try {
+            const parsed = JSON.parse(scopesJson);
+            if (Array.isArray(parsed) && parsed.every((scope) => typeof scope === "string"))
+                return parsed;
+        }
+        catch {
+            // Fall back to legacy comma-separated metadata below.
+        }
+    }
+    const scopes = scopesText.split(",").map((scope) => scope.trim()).filter(Boolean);
+    return scopes.length > 0 ? scopes : fallback;
+}
+function rebuildCommand(indexableFiles, smallRepoThreshold) {
+    const parts = ["project-librarian", "--code-index", "--code-index-full"];
+    if (indexableFiles !== null && indexableFiles < smallRepoThreshold)
+        parts.push("--acknowledge-small-repo");
+    return parts.join(" ");
+}
+function baseHealth(options, status, message, indexableFiles) {
+    return {
+        database_path: options.relativePath,
+        expected_schema_version: options.expectedSchemaVersion,
+        found_schema_version: "",
+        indexed_files: null,
+        indexable_files: indexableFiles,
+        message,
+        parser_mode: "",
+        recommended_rebuild_command: rebuildCommand(indexableFiles, options.smallRepoThreshold),
+        scopes: options.defaultScopes,
+        status,
+        tables: [],
+        updated_at: "",
+    };
+}
+function inspectCodeIndexHealth(options) {
+    if (!fs.existsSync(options.absolutePath)) {
+        const indexableFiles = safeDiscoverCodeFiles(options.discoverCodeFiles, options.defaultScopes);
+        return baseHealth(options, "missing", `missing code evidence index: ${options.relativePath}`, indexableFiles);
+    }
+    let database;
+    try {
+        database = options.openDatabase(options.absolutePath);
+    }
+    catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        const indexableFiles = safeDiscoverCodeFiles(options.discoverCodeFiles, options.defaultScopes);
+        return baseHealth(options, "unreadable", `code evidence index is not readable: ${message}`, indexableFiles);
+    }
+    try {
+        database.exec("PRAGMA query_only = ON");
+        const tables = tableNames(database);
+        const foundSchemaVersion = safeScalar(database, "SELECT value FROM meta WHERE key = ?", "schema_version");
+        const updatedAt = safeScalar(database, "SELECT value FROM meta WHERE key = ?", "updated_at");
+        const parserMode = safeScalar(database, "SELECT value FROM meta WHERE key = ?", "parser_mode");
+        const scopes = readScopes(safeScalar(database, "SELECT value FROM meta WHERE key = ?", "scopes_json"), safeScalar(database, "SELECT value FROM meta WHERE key = ?", "scopes"), options.defaultScopes);
+        const indexedFilesText = tables.includes("files") ? safeScalar(database, "SELECT count(*) AS value FROM files") : "";
+        const indexedFiles = indexedFilesText ? Number(indexedFilesText) : null;
+        const indexableFiles = safeDiscoverCodeFiles(options.discoverCodeFiles, scopes.length > 0 ? scopes : options.defaultScopes);
+        const compatible = foundSchemaVersion === options.expectedSchemaVersion;
+        return {
+            database_path: options.relativePath,
+            expected_schema_version: options.expectedSchemaVersion,
+            found_schema_version: foundSchemaVersion,
+            indexed_files: indexedFiles !== null && Number.isFinite(indexedFiles) ? indexedFiles : null,
+            indexable_files: indexableFiles,
+            message: compatible
+                ? `code evidence index is compatible: schema ${foundSchemaVersion}`
+                : `code evidence index schema version ${foundSchemaVersion || "(missing)"} is incompatible with ${options.expectedSchemaVersion}`,
+            parser_mode: parserMode,
+            recommended_rebuild_command: rebuildCommand(indexableFiles, options.smallRepoThreshold),
+            scopes,
+            status: compatible ? "compatible" : "incompatible_schema",
+            tables,
+            updated_at: updatedAt,
+        };
+    }
+    catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        const indexableFiles = safeDiscoverCodeFiles(options.discoverCodeFiles, options.defaultScopes);
+        return baseHealth(options, "unreadable", `code evidence index is not readable: ${message}`, indexableFiles);
+    }
+    finally {
+        database.close();
+    }
+}
+function formatCodeIndexHealthRemediation(health) {
+    return [
+        health.message,
+        `database: ${health.database_path}`,
+        `status: ${health.status}`,
+        `expected_schema_version: ${health.expected_schema_version}`,
+        `found_schema_version: ${health.found_schema_version || "(missing)"}`,
+        `rebuild: ${health.recommended_rebuild_command}`,
+    ].join("\n");
+}