project-librarian 0.5.5 → 0.5.6

package/dist/code-index/schema.js

@@ -1,6 +1,41 @@
 "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.codeIndexSchemaVersion = void 0;
+exports.fileFtsRowid = fileFtsRowid;
+exports.createSecondaryIndexes = createSecondaryIndexes;
 exports.setupDatabase = setupDatabase;
 exports.createIndexStatements = createIndexStatements;
 exports.removeIndexedFile = removeIndexedFile;
@@ -10,14 +45,44 @@ exports.indexedScopes = indexedScopes;
 exports.indexedParserMode = indexedParserMode;
 exports.incrementalCompatibility = incrementalCompatibility;
 exports.codeIndexSnapshot = codeIndexSnapshot;
+const crypto = __importStar(require("node:crypto"));
 const workspace_1 = require("../workspace");
-exports.codeIndexSchemaVersion = "4";
-function setupDatabase(database) {
+exports.codeIndexSchemaVersion = "5";
+function stableFtsRowid(parts) {
+    const hash = crypto.createHash("sha256");
+    for (const part of parts) {
+        hash.update(part);
+        hash.update("\0");
+    }
+    const digest = hash.digest();
+    let value = 0;
+    for (let index = 0; index < 6; index += 1)
+        value = value * 256 + digest[index];
+    return value + 1;
+}
+function fileFtsRowid(filePath) {
+    return stableFtsRowid(["file", filePath]);
+}
+const secondaryIndexSql = `
+  CREATE INDEX idx_symbols_file ON symbols(file_path);
+  CREATE INDEX idx_symbols_name ON symbols(name);
+  CREATE INDEX idx_imports_from ON imports(from_file);
+  CREATE INDEX idx_routes_path ON routes(route);
+  CREATE INDEX idx_configs_file ON configs(file_path);
+  CREATE INDEX idx_edges_source ON edges(source_kind, source);
+  CREATE INDEX idx_edges_target ON edges(target_kind, target);
+  CREATE INDEX idx_edges_kind ON edges(kind);
+`;
+function createSecondaryIndexes(database) {
+    database.exec(secondaryIndexSql);
+}
+function setupDatabase(database, options = {}) {
     database.exec(`
     PRAGMA journal_mode = WAL;
     CREATE TABLE meta (key TEXT PRIMARY KEY, value TEXT NOT NULL);
     CREATE TABLE files (
       path TEXT PRIMARY KEY,
+      fts_rowid INTEGER NOT NULL UNIQUE,
       language TEXT NOT NULL,
       profile TEXT NOT NULL,
       kind TEXT NOT NULL,
@@ -71,30 +136,24 @@ function setupDatabase(database) {
     );
     CREATE VIRTUAL TABLE files_fts USING fts5(path, language, profile, content);
     CREATE VIRTUAL TABLE symbols_fts USING fts5(name, kind, file_path, signature);
-    CREATE INDEX idx_symbols_file ON symbols(file_path);
-    CREATE INDEX idx_symbols_name ON symbols(name);
-    CREATE INDEX idx_imports_from ON imports(from_file);
-    CREATE INDEX idx_routes_path ON routes(route);
-    CREATE INDEX idx_configs_file ON configs(file_path);
-    CREATE INDEX idx_edges_source ON edges(source_kind, source);
-    CREATE INDEX idx_edges_target ON edges(target_kind, target);
-    CREATE INDEX idx_edges_kind ON edges(kind);
   `);
+    if (options.secondaryIndexes ?? true)
+        createSecondaryIndexes(database);
 }
 function createIndexStatements(database) {
     return {
         deleteConfig: database.prepare("DELETE FROM configs WHERE file_path = ?"),
         deleteEdge: database.prepare("DELETE FROM edges WHERE file_path = ?"),
         deleteFile: database.prepare("DELETE FROM files WHERE path = ?"),
-        deleteFileFts: database.prepare("DELETE FROM files_fts WHERE path = ?"),
+        deleteFileFts: database.prepare("DELETE FROM files_fts WHERE rowid = (SELECT fts_rowid FROM files WHERE path = ?)"),
         deleteImport: database.prepare("DELETE FROM imports WHERE from_file = ?"),
         deleteRoute: database.prepare("DELETE FROM routes WHERE file_path = ?"),
         deleteSymbol: database.prepare("DELETE FROM symbols WHERE file_path = ?"),
         deleteSymbolFts: database.prepare("DELETE FROM symbols_fts WHERE file_path = ?"),
         insertConfig: database.prepare("INSERT INTO configs (key, value, file_path, line) VALUES (?, ?, ?, ?)"),
         insertEdge: database.prepare("INSERT INTO edges (kind, source_kind, source, target_kind, target, file_path, line, evidence) VALUES (?, ?, ?, ?, ?, ?, ?, ?)"),
-        insertFile: database.prepare("INSERT INTO files (path, language, profile, kind, bytes, lines, hash, mtime_ms, size) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?)"),
-        insertFileFts: database.prepare("INSERT INTO files_fts (path, language, profile, content) VALUES (?, ?, ?, ?)"),
+        insertFile: database.prepare("INSERT INTO files (path, fts_rowid, language, profile, kind, bytes, lines, hash, mtime_ms, size) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?)"),
+        insertFileFts: database.prepare("INSERT INTO files_fts (rowid, path, language, profile, content) VALUES (?, ?, ?, ?, ?)"),
         insertImport: database.prepare("INSERT INTO imports (from_file, to_ref, imported, line, raw) VALUES (?, ?, ?, ?, ?)"),
         insertMeta: database.prepare("INSERT OR REPLACE INTO meta (key, value) VALUES (?, ?)"),
         insertRoute: database.prepare("INSERT INTO routes (method, route, file_path, line, handler) VALUES (?, ?, ?, ?, ?)"),

package/dist/code-index/search.js

@@ -82,7 +82,7 @@ function searchFiles(database, term, limit = 25) {
         const ftsRows = database.prepare(`
       SELECT files.path, files.language, files.profile, files.lines, files.bytes
       FROM files_fts
-      JOIN files ON files.path = files_fts.path
+      JOIN files ON files.fts_rowid = files_fts.rowid
       WHERE files_fts MATCH ?
       ORDER BY bm25(files_fts, 8.0, 1.0, 1.0, 0.25), files.path
       LIMIT ?

package/dist/code-index-file-policy.js

@@ -38,6 +38,7 @@ exports.fileLanguage = fileLanguage;
 exports.isJavaScriptLike = isJavaScriptLike;
 exports.shouldIndexFile = shouldIndexFile;
 exports.isIgnoredCodePath = isIgnoredCodePath;
+exports.cachedDiscoveredCodeFileStat = cachedDiscoveredCodeFileStat;
 exports.discoverCodeFiles = discoverCodeFiles;
 exports.smallRepoCodeIndexGate = smallRepoCodeIndexGate;
 const childProcess = __importStar(require("node:child_process"));
@@ -76,6 +77,7 @@ const languageByExtension = {
 };
 const configExtensions = new Set([".json", ".yaml", ".yml", ".toml"]);
 exports.maxIndexedBytes = 1024 * 1024;
+const discoveredCodeFileStats = new Map();
 function fileLanguage(relativePath) {
     if (path.basename(relativePath) === ".env.example")
         return "config";
@@ -170,7 +172,11 @@ function gitTrackedAndUnignoredFiles(scopes) {
 function indexableFileStat(file) {
     return (0, workspace_1.containedProjectFileStat)(file);
 }
+function cachedDiscoveredCodeFileStat(relativePath) {
+    return discoveredCodeFileStats.get(relativePath);
+}
 function discoverCodeFiles(scopes) {
+    discoveredCodeFileStats.clear();
     const gitFiles = gitTrackedAndUnignoredFiles(scopes);
     const candidates = gitFiles ?? scopes.flatMap((scope) => walkCodeFiles(scope));
     const files = [];
@@ -178,8 +184,10 @@ function discoverCodeFiles(scopes) {
         if (isIgnoredCodePath(file) || !shouldIndexFile(file))
             continue;
         const stat = indexableFileStat(file);
-        if (stat && stat.size <= exports.maxIndexedBytes)
+        if (stat && stat.size <= exports.maxIndexedBytes) {
+            discoveredCodeFileStats.set(file, { absolutePath: (0, workspace_1.abs)(file), stat });
             files.push(file);
+        }
     }
     return files.sort();
 }

package/dist/code-index.js

@@ -33,7 +33,7 @@ var __importStar = (this && this.__importStar) || (function () {
     };
 })();
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.CodeEvidenceIndexUnavailableError = exports.codeContextPackTruncationNotice = exports.codeContextPackCharCap = exports.codeIndexSnapshot = exports.workspaceSummary = exports.workspaceDependencyGraph = exports.searchSymbols = exports.ownershipInfo = exports.ownershipContext = exports.matchedCodeownerRules = exports.evidenceCoverage = exports.codeownerRules = void 0;
+exports.CodeEvidenceIndexUnavailableError = exports.nativeCodeIndexAutoFileThreshold = exports.codeContextPackTruncationNotice = exports.codeContextPackCharCap = exports.codeIndexSnapshot = exports.workspaceSummary = exports.workspaceDependencyGraph = exports.searchSymbols = exports.ownershipInfo = exports.ownershipContext = exports.matchedCodeownerRules = exports.evidenceCoverage = exports.codeownerRules = void 0;
 exports.codeIndexStaleness = codeIndexStaleness;
 exports.codeIndexHealth = codeIndexHealth;
 exports.codeImpact = codeImpact;
@@ -61,6 +61,7 @@ const registry_1 = require("./code-index/extractors/registry");
 const shared_1 = require("./code-index/extractors/shared");
 const index_health_1 = require("./code-index/index-health");
 const modes_1 = require("./code-index/modes");
+const native_helper_1 = require("./code-index/native-helper");
 const ownership_1 = require("./code-index/ownership");
 Object.defineProperty(exports, "codeownerRules", { enumerable: true, get: function () { return ownership_1.codeownerRules; } });
 Object.defineProperty(exports, "matchedCodeownerRules", { enumerable: true, get: function () { return ownership_1.matchedCodeownerRules; } });
@@ -77,6 +78,8 @@ Object.defineProperty(exports, "searchSymbols", { enumerable: true, get: functio
 const workspace_1 = require("./workspace");
 exports.codeContextPackCharCap = 4000;
 exports.codeContextPackTruncationNotice = "[truncated - refine the query]";
+exports.nativeCodeIndexAutoFileThreshold = 1;
+const codeFileFingerprintPaths = new Map();
 function fail(message) {
     console.error(message);
     process.exit(1);
@@ -110,31 +113,82 @@ function selectedCodeParserMode() {
         return "tree-sitter";
     fail(`invalid --code-parser: ${args_1.codeParser}; expected one of: default, tree-sitter`);
 }
+function selectedCodeIndexEngine() {
+    const requested = args_1.codeIndexEngine.trim().toLowerCase();
+    if (!requested || requested === "auto")
+        return "auto";
+    if (requested === "typescript")
+        return "typescript";
+    if (requested === "native-rust")
+        return "native-rust";
+    fail(`invalid --code-index-engine: ${args_1.codeIndexEngine}; expected one of: auto, typescript, native-rust`);
+}
+function codeIndexEngineSelectionContext(discoveredFiles, parserMode) {
+    let nativeEligibleFileCount = 0;
+    for (const filePath of discoveredFiles) {
+        const language = (0, code_index_file_policy_1.fileLanguage)(filePath) || "config";
+        if (nativeAutoEligibleProfile((0, registry_1.extractionProfile)(filePath, language, parserMode)))
+            nativeEligibleFileCount += 1;
+    }
+    return {
+        discoveredFileCount: discoveredFiles.length,
+        nativeEligibleFileCount,
+        nativeIneligibleFileCount: discoveredFiles.length - nativeEligibleFileCount,
+    };
+}
+function shouldUseNativeCodeIndexAuto(context) {
+    return context.nativeEligibleFileCount >= exports.nativeCodeIndexAutoFileThreshold
+        && (0, native_helper_1.nativeCodeIndexHelperAvailable)();
+}
+function nativeCodeIndexAvailable() {
+    return (0, native_helper_1.nativeCodeIndexHelperAvailable)();
+}
 function normalizedMtimeMs(stat) {
     return Number(stat.mtimeMs.toFixed(3));
 }
 function readCodeFileFingerprint(relativePath) {
-    const { stat } = (0, workspace_1.requireContainedProjectFile)(relativePath, "code-index file");
+    const discovered = (0, code_index_file_policy_1.cachedDiscoveredCodeFileStat)(relativePath);
+    const { absolutePath, stat } = discovered ?? (0, workspace_1.requireContainedProjectFile)(relativePath, "code-index file");
+    codeFileFingerprintPaths.set(relativePath, absolutePath);
     return {
         mtimeMs: normalizedMtimeMs(stat),
         path: relativePath,
         size: stat.size,
     };
 }
-function readCodeFile(relativePath, parserMode = "default") {
-    const { absolutePath } = (0, workspace_1.requireContainedProjectFile)(relativePath, "code-index file");
+function lineCount(text) {
+    if (text.length === 0)
+        return 0;
+    let lines = 1;
+    for (let index = 0; index < text.length; index += 1) {
+        if (text.charCodeAt(index) === 10)
+            lines += 1;
+    }
+    return lines;
+}
+function readCodeFile(relativePath, parserMode = "default", fingerprint) {
+    let effectiveFingerprint = fingerprint;
+    let absolutePath = effectiveFingerprint ? codeFileFingerprintPaths.get(relativePath) : undefined;
+    if (!absolutePath || !effectiveFingerprint) {
+        const contained = (0, workspace_1.requireContainedProjectFile)(relativePath, "code-index file");
+        absolutePath = contained.absolutePath;
+        effectiveFingerprint ??= {
+            mtimeMs: normalizedMtimeMs(contained.stat),
+            path: relativePath,
+            size: contained.stat.size,
+        };
+    }
     const text = fs.readFileSync(absolutePath, "utf8");
-    const fingerprint = readCodeFileFingerprint(relativePath);
     const language = (0, code_index_file_policy_1.fileLanguage)(relativePath) || "config";
     return {
-        bytes: fingerprint.size,
+        bytes: effectiveFingerprint.size,
         hash: crypto.createHash("sha256").update(text).digest("hex"),
         language,
-        lines: text.length === 0 ? 0 : text.split(/\r?\n/).length,
-        mtimeMs: fingerprint.mtimeMs,
+        lines: lineCount(text),
+        mtimeMs: effectiveFingerprint.mtimeMs,
         path: relativePath,
         profile: (0, registry_1.extractionProfile)(relativePath, language, parserMode),
-        size: fingerprint.size,
+        size: effectiveFingerprint.size,
         text,
     };
 }
@@ -143,8 +197,9 @@ function extractionBackendForProfile(profile) {
     return extractionBackendRegistry.backendForProfile(profile);
 }
 function indexCodeFile(file, statements) {
-    statements.insertFile.run(file.path, file.language, file.profile, file.language === "config" ? "config" : "source", file.bytes, file.lines, file.hash, file.mtimeMs, file.size);
-    statements.insertFileFts.run(file.path, file.language, file.profile, file.text);
+    const ftsRowid = (0, schema_1.fileFtsRowid)(file.path);
+    statements.insertFile.run(file.path, ftsRowid, file.language, file.profile, file.language === "config" ? "config" : "source", file.bytes, file.lines, file.hash, file.mtimeMs, file.size);
+    statements.insertFileFts.run(ftsRowid, file.path, file.language, file.profile, file.text);
     extractionBackendForProfile(file.profile).index(file, statements);
 }
 function printRows(rows) {
@@ -173,6 +228,295 @@ function removeDatabaseFiles(databasePath) {
             fs.unlinkSync(filePath);
     }
 }
+function moveDatabaseFiles(sourcePath, targetPath) {
+    const backupPath = `${targetPath}.backup-${process.pid}-${Date.now()}`;
+    removeDatabaseFiles(backupPath);
+    for (const suffix of ["", "-wal", "-shm"]) {
+        const target = `${targetPath}${suffix}`;
+        if (fs.existsSync(target))
+            fs.renameSync(target, `${backupPath}${suffix}`);
+    }
+    try {
+        for (const suffix of ["", "-wal", "-shm"]) {
+            const source = `${sourcePath}${suffix}`;
+            if (fs.existsSync(source))
+                fs.renameSync(source, `${targetPath}${suffix}`);
+        }
+        removeDatabaseFiles(backupPath);
+    }
+    catch (error) {
+        removeDatabaseFiles(targetPath);
+        for (const suffix of ["", "-wal", "-shm"]) {
+            const backup = `${backupPath}${suffix}`;
+            if (fs.existsSync(backup))
+                fs.renameSync(backup, `${targetPath}${suffix}`);
+        }
+        throw error;
+    }
+}
+function removeTemporaryDatabaseFiles(databasePath) {
+    for (const suffix of ["", "-wal", "-shm"]) {
+        const filePath = `${databasePath}${suffix}`;
+        if (fs.existsSync(filePath))
+            fs.unlinkSync(filePath);
+    }
+}
+function nativeCodeIndexFileFor(filePath, parserMode) {
+    const fingerprint = readCodeFileFingerprint(filePath);
+    const language = (0, code_index_file_policy_1.fileLanguage)(filePath) || "config";
+    return {
+        ...fingerprint,
+        language,
+        profile: (0, registry_1.extractionProfile)(filePath, language, parserMode),
+    };
+}
+function nativeCodeIndexFileFromCodeFile(file) {
+    return {
+        language: file.language,
+        mtimeMs: file.mtimeMs,
+        path: file.path,
+        profile: file.profile,
+        size: file.size,
+    };
+}
+function nativeCodeIndexFileFromFingerprint(file, parserMode) {
+    const language = (0, code_index_file_policy_1.fileLanguage)(file.path) || "config";
+    return {
+        language,
+        mtimeMs: file.mtimeMs,
+        path: file.path,
+        profile: (0, registry_1.extractionProfile)(file.path, language, parserMode),
+        size: file.size,
+    };
+}
+function nativeEligibleProfile(profile) {
+    return nativeAutoEligibleProfile(profile) || profile === "config" || profile === "inventory-only";
+}
+function nativeCodeIndexIncrementalEligible(files, parserMode) {
+    return files.every((file) => nativeEligibleProfile(nativeCodeIndexFileFromFingerprint(file, parserMode).profile));
+}
+function nativeAutoEligibleProfile(profile) {
+    return [
+        "typescript-ast",
+        "python-light",
+        "go-light",
+        "c-light",
+        "cpp-light",
+        "csharp-light",
+        "java-light",
+        "kotlin-light",
+        "php-light",
+        "rust-light",
+        "swift-light",
+    ].includes(profile);
+}
+function nativeCodeIndexOutputMode() {
+    const requested = (process.env.PROJECT_LIBRARIAN_NATIVE_INDEXER_STRATEGY ?? "sqlite-direct").trim();
+    if (requested === "row-stream" || requested === "sqlite-bridge" || requested === "sqlite-direct")
+        return requested;
+    fail(`invalid PROJECT_LIBRARIAN_NATIVE_INDEXER_STRATEGY: ${requested}; expected row-stream, sqlite-bridge, or sqlite-direct`);
+}
+function appendTypeScriptPartitionToNativeDatabase(databasePath, files, parserMode) {
+    if (files.length === 0)
+        return 0;
+    const database = openDatabase(databasePath);
+    try {
+        const statements = (0, schema_1.createIndexStatements)(database);
+        database.exec("BEGIN");
+        for (const file of files)
+            indexCodeFile(readCodeFile(file.path, parserMode, file), statements);
+        database.exec("COMMIT");
+        return files.length;
+    }
+    catch (error) {
+        try {
+            database.exec("ROLLBACK");
+        }
+        catch {
+            // Ignore rollback failures after helper-created database errors.
+        }
+        throw error;
+    }
+    finally {
+        database.close();
+    }
+}
+function writeNativeRowsToDatabase(databasePath, rows, scopes, parserMode) {
+    removeDatabaseFiles(databasePath);
+    const database = openDatabase(databasePath);
+    try {
+        (0, schema_1.setupDatabase)(database, { secondaryIndexes: false });
+        const statements = (0, schema_1.createIndexStatements)(database);
+        database.exec("BEGIN");
+        statements.insertMeta.run("created_at", new Date().toISOString());
+        (0, schema_1.writeIndexMetadata)(scopes, parserMode, statements);
+        for (const file of rows.files) {
+            const ftsRowid = (0, schema_1.fileFtsRowid)(file.path);
+            statements.insertFile.run(file.path, ftsRowid, file.language, file.profile, file.kind, file.bytes, file.lines, file.hash, file.mtime_ms, file.size);
+            statements.insertFileFts.run(ftsRowid, file.path, file.language, file.profile, file.content);
+        }
+        for (const symbol of rows.symbols) {
+            statements.insertSymbol.run(symbol.name, symbol.kind, symbol.file_path, symbol.line, symbol.signature);
+            statements.insertSymbolFts.run(symbol.name, symbol.kind, symbol.file_path, symbol.signature);
+        }
+        for (const imported of rows.imports) {
+            statements.insertImport.run(imported.from_file, imported.to_ref, imported.imported, imported.line, imported.raw);
+        }
+        for (const route of rows.routes) {
+            statements.insertRoute.run(route.method, route.route, route.file_path, route.line, route.handler);
+        }
+        for (const config of rows.configs) {
+            statements.insertConfig.run(config.key, config.value, config.file_path, config.line);
+        }
+        for (const edge of rows.edges) {
+            statements.insertEdge.run(edge.kind, edge.source_kind, edge.source, edge.target_kind, edge.target, edge.file_path, edge.line, edge.evidence);
+        }
+        (0, schema_1.createSecondaryIndexes)(database);
+        database.exec("COMMIT");
+    }
+    catch (error) {
+        try {
+            database.exec("ROLLBACK");
+        }
+        catch {
+            // Ignore rollback failures after row-stream setup errors.
+        }
+        throw error;
+    }
+    finally {
+        database.close();
+    }
+}
+function runNativeCodeIndexMode(request) {
+    let helperPath = "";
+    try {
+        helperPath = (0, native_helper_1.requireNativeCodeIndexHelperPath)();
+    }
+    catch (error) {
+        fail(error instanceof Error ? error.message : String(error));
+    }
+    prepareOutputPath();
+    const tempDatabasePath = `${request.databasePath.absolutePath}.native-${process.pid}-${Date.now()}.tmp`;
+    removeDatabaseFiles(tempDatabasePath);
+    const manifestFiles = [];
+    const nativeFiles = [];
+    const typescriptFiles = [];
+    for (const filePath of request.discoveredFiles) {
+        const file = nativeCodeIndexFileFor(filePath, request.parserMode);
+        manifestFiles.push(file);
+        if (nativeEligibleProfile(file.profile))
+            nativeFiles.push(file);
+        else
+            typescriptFiles.push(file);
+    }
+    const typescriptProfiles = [...new Set(typescriptFiles.map((file) => file.profile))].sort();
+    const outputMode = nativeCodeIndexOutputMode();
+    const rowsPath = `${tempDatabasePath}.rows.json`;
+    const job = (0, native_helper_1.buildNativeCodeIndexJob)({
+        database_path: tempDatabasePath,
+        files: nativeFiles,
+        output_mode: outputMode,
+        parser_mode: request.parserMode,
+        schema_version: schema_1.codeIndexSchemaVersion,
+        scopes: request.scopes,
+        ...(outputMode === "row-stream" ? { rows_path: rowsPath } : {}),
+    });
+    let summary;
+    let typescriptIndexedFiles = 0;
+    try {
+        if (outputMode === "row-stream") {
+            const result = (0, native_helper_1.runNativeCodeIndexRowsHelper)(job, { helperPath });
+            summary = result.summary;
+            writeNativeRowsToDatabase(tempDatabasePath, result.rows, request.scopes, request.parserMode);
+        }
+        else {
+            summary = (0, native_helper_1.runNativeCodeIndexHelper)(job, { helperPath });
+        }
+        if (!fs.existsSync(tempDatabasePath)) {
+            fail(`native code index helper did not create database: ${tempDatabasePath}`);
+        }
+        typescriptIndexedFiles = appendTypeScriptPartitionToNativeDatabase(tempDatabasePath, typescriptFiles, request.parserMode);
+        moveDatabaseFiles(tempDatabasePath, request.databasePath.absolutePath);
+    }
+    catch (error) {
+        removeTemporaryDatabaseFiles(tempDatabasePath);
+        fail(error instanceof Error ? error.message : String(error));
+    }
+    finally {
+        if (fs.existsSync(rowsPath))
+            fs.unlinkSync(rowsPath);
+    }
+    console.log("Project wiki code evidence index complete.");
+    console.log(`database: ${request.databasePath.relativePath}`);
+    console.log("mode: full");
+    console.log(`parser_mode: ${request.parserMode}`);
+    console.log(`engine: ${typescriptIndexedFiles > 0 ? "mixed-native-rust" : "native-rust"}`);
+    if (request.requestedEngine === "auto")
+        console.log("engine_selection: auto");
+    console.log(`native_strategy: ${outputMode}`);
+    console.log(`scopes: ${request.scopes.join(", ")}`);
+    console.log(`files: ${manifestFiles.length}`);
+    console.log(`native_files: ${nativeFiles.length}`);
+    console.log(`typescript_files: ${typescriptIndexedFiles}`);
+    if (typescriptProfiles.length > 0)
+        console.log(`typescript_profiles: ${typescriptProfiles.join(", ")}`);
+    console.log(`reindexed_files: ${manifestFiles.length}`);
+    console.log(`deleted_files: ${summary.deleted_files ?? 0}`);
+    console.log(`unchanged_files: ${summary.unchanged_files ?? 0}`);
+}
+function runNativeCodeIndexIncrementalMode(request) {
+    let helperPath = "";
+    try {
+        helperPath = (0, native_helper_1.requireNativeCodeIndexHelperPath)();
+    }
+    catch (error) {
+        fail(error instanceof Error ? error.message : String(error));
+    }
+    const nativeFiles = request.reindexedFiles.map((file) => nativeCodeIndexFileFromFingerprint(file, request.parserMode));
+    const ineligibleProfiles = [...new Set(nativeFiles
+            .filter((file) => !nativeEligibleProfile(file.profile))
+            .map((file) => file.profile))].sort();
+    if (ineligibleProfiles.length > 0) {
+        fail(`native incremental writer does not support parser profiles: ${ineligibleProfiles.join(", ")}`);
+    }
+    prepareOutputPath();
+    const outputMode = "sqlite-direct";
+    const job = (0, native_helper_1.buildNativeCodeIndexJob)({
+        database_path: request.databasePath.absolutePath,
+        deleted_paths: request.deletedPaths,
+        files: nativeFiles,
+        mode: "incremental",
+        output_mode: outputMode,
+        parser_mode: request.parserMode,
+        schema_version: schema_1.codeIndexSchemaVersion,
+        scopes: request.scopes,
+    });
+    let summary;
+    try {
+        summary = (0, native_helper_1.runNativeCodeIndexHelper)(job, { helperPath });
+        if (!fs.existsSync(request.databasePath.absolutePath)) {
+            fail(`native incremental writer did not preserve database: ${request.databasePath.absolutePath}`);
+        }
+    }
+    catch (error) {
+        fail(error instanceof Error ? error.message : String(error));
+    }
+    console.log("Project wiki code evidence index complete.");
+    console.log(`database: ${request.databasePath.relativePath}`);
+    console.log("mode: incremental");
+    console.log(`parser_mode: ${request.parserMode}`);
+    console.log("engine: native-rust");
+    if (request.requestedEngine === "auto")
+        console.log("engine_selection: auto");
+    console.log(`native_strategy: ${outputMode}`);
+    console.log(`scopes: ${request.scopes.join(", ")}`);
+    console.log(`files: ${request.discoveredFiles.length}`);
+    console.log(`native_files: ${nativeFiles.length}`);
+    console.log("typescript_files: 0");
+    console.log(`reindexed_files: ${summary.reindexed_files ?? nativeFiles.length}`);
+    console.log(`deleted_files: ${summary.deleted_files ?? request.deletedPaths.length}`);
+    console.log(`unchanged_files: ${request.unchangedFiles}`);
+}
 function codeIndexStaleness(database) {
     const scopes = (0, schema_1.indexedScopes)(database);
     const parserMode = (0, schema_1.indexedParserMode)(database);
@@ -194,7 +538,7 @@ function codeIndexStaleness(database) {
         }
         if (existing.mtimeMs === file.mtimeMs && existing.size === file.size)
             continue;
-        if (readCodeFile(file.path, parserMode).hash !== existing.hash)
+        if (readCodeFile(file.path, parserMode, file).hash !== existing.hash)
             changed += 1;
     }
     const deleted = indexedRows.filter((row) => !currentPaths.has(String(row.path))).length;
@@ -397,13 +741,20 @@ function codeIndexModeRuntime() {
         codeScopes,
         fail,
         indexCodeFile,
+        nativeCodeIndexAvailable,
+        nativeCodeIndexIncrementalEligible,
         openDatabase,
         prepareOutputPath,
         readCodeFileFingerprint,
         readCodeFile,
         removeDatabaseFiles,
         requireExistingIndex,
+        runNativeCodeIndexIncrementalMode,
+        runNativeCodeIndexMode,
+        selectedCodeIndexEngine,
         selectedCodeParserMode,
+        codeIndexEngineSelectionContext,
+        shouldUseNativeCodeIndexAuto,
         warnIfCodeIndexStale,
     };
 }

package/dist/init-project-wiki.js

@@ -62,6 +62,7 @@ Options:
   --acknowledge-small-repo         With --code-index, proceed below the small-repo scale gate after its cost warning.
   --incremental                    With --code-index, require an existing compatible index and update only changes.
   --code-index-full                With --code-index, force a full rebuild even when incremental update is possible.
+  --code-index-engine <engine>     With --code-index, override default auto engine: typescript or native-rust.
   --code-parser <mode>             With --code-index, use parser mode default or tree-sitter.
   --code-query <sql>               Run conservative read-only SQL over the code evidence index.
   --code-status, --code-files      Inspect the code evidence index.
@@ -165,6 +166,10 @@ if (args_1.codeIndexFullMode && !args_1.codeIndexMode) {
     console.error("--code-index-full is only supported with --code-index.");
     process.exit(1);
 }
+if (args_1.codeIndexEngineMode && !args_1.codeIndexMode) {
+    console.error("--code-index-engine is only supported with --code-index.");
+    process.exit(1);
+}
 if (args_1.codeParserMode && !args_1.codeIndexMode) {
     console.error("--code-parser is only supported with --code-index.");
     process.exit(1);