akm-cli 0.9.17-alpha.2 → 0.9.17-alpha.4

package/dist/indexer/ensure-index.js

@@ -23,12 +23,13 @@ import fs from "node:fs";
 import path from "node:path";
 import { hashContent } from "../core/adapter/adapters/shared.js";
 import { placementSpecList } from "../core/asset/asset-placement.js";
+import { ConfigError } from "../core/errors.js";
 import { classifyPathAccess } from "../core/path-access.js";
 import { getDbPath } from "../core/paths.js";
 import { warnVerbose } from "../core/warn.js";
 import { assertIndexPathReadable, closeDatabase, openExistingDatabase } from "../storage/repositories/index-connection.js";
 import { getEntryCount, getIndexedFileHashes, getIndexedFilePaths, } from "../storage/repositories/index-entries-repository.js";
-import { isCanonicalIndexGeneration } from "../storage/repositories/index-entry-schema.js";
+import { hasCurrentEntriesTable } from "../storage/repositories/index-entry-schema.js";
 import { getMeta } from "../storage/repositories/index-meta-repository.js";
 import { warnOnBundleRenameDrift } from "./bundle-identity-guard.js";
 function getIndexableFiles(root, spec) {
@@ -134,49 +135,11 @@ function hasNewerIndexableFiles(stashDir, builtAt, indexedPaths, indexedHashes)
 }
 /**
  * Check whether the local index is stale relative to the given stash directory.
- * Returns `true` when the index is missing, empty, or was built against a
- * different primary stash dir.
+ * Returns `true` when the index is missing, empty, was built against a
+ * different primary stash dir, or an indexable file is newer than it.
  */
 export function isIndexStale(stashDir) {
-    const dbPath = getDbPath();
-    // Raises on an index we cannot READ rather than calling it stale — "stale"
-    // sends us into an inline reindex that will fail anyway, and whose failure is
-    // reported as the misleading "proceeding with existing index" (#791).
-    assertIndexPathReadable(dbPath);
-    if (classifyPathAccess(dbPath).access === "absent")
-        return true;
-    let db;
-    try {
-        db = openExistingDatabase(dbPath);
-        if (!isCanonicalIndexGeneration(db))
-            return true;
-        const entryCount = getEntryCount(db);
-        if (entryCount === 0)
-            return true;
-        const builtAt = getMeta(db, "builtAt");
-        if (hasNewerIndexableFiles(stashDir, builtAt, getIndexedFilePaths(db), getIndexedFileHashes(db)))
-            return true;
-        const storedStashDir = getMeta(db, "stashDir");
-        if (storedStashDir !== stashDir) {
-            // Check if the incoming stashDir appears in the stored stashDirs array
-            try {
-                const storedDirs = JSON.parse(getMeta(db, "stashDirs") ?? "[]");
-                if (!storedDirs.includes(stashDir))
-                    return true;
-            }
-            catch {
-                return true;
-            }
-        }
-        return false;
-    }
-    catch {
-        return true;
-    }
-    finally {
-        if (db)
-            closeDatabase(db);
-    }
+    return !indexCanServeStash(stashDir, { requireFresh: true });
 }
 /**
  * Whether the existing index can serve queries for `stashDir` *right now* —
@@ -186,20 +149,27 @@ export function isIndexStale(stashDir) {
  * content-stale, so read paths serve it as-is. When it is false the existing
  * index has nothing relevant to return (no DB, no `entries` table, zero rows,
  * or built for a different stash), so those cases must rebuild inline.
+ * `requireFresh` also demands that no indexable file is newer than the index.
  */
-function indexCanServeStash(stashDir) {
-    // Same rule as isIndexStale: unreadable is an error, not "cannot serve" (#791).
+function indexCanServeStash(stashDir, options = {}) {
     const dbPath = getDbPath();
+    // Raises on an index we cannot READ rather than calling it unusable — that
+    // sends us into an inline reindex that will fail anyway, and whose failure
+    // is reported as the misleading "proceeding with existing index" (#791).
     assertIndexPathReadable(dbPath);
     if (classifyPathAccess(dbPath).access === "absent")
         return false;
     let db;
     try {
         db = openExistingDatabase(dbPath);
-        if (!isCanonicalIndexGeneration(db))
+        if (!hasCurrentEntriesTable(db))
             return false;
         if (getEntryCount(db) === 0)
             return false;
+        if (options.requireFresh &&
+            hasNewerIndexableFiles(stashDir, getMeta(db, "builtAt"), getIndexedFilePaths(db), getIndexedFileHashes(db))) {
+            return false;
+        }
         const storedStashDir = getMeta(db, "stashDir");
         if (storedStashDir === stashDir)
             return true;
@@ -211,7 +181,10 @@ function indexCanServeStash(stashDir) {
             return false;
         }
     }
-    catch {
+    catch (error) {
+        // A newer layout's refusal names the remedy; a rebuild would refuse too.
+        if (error instanceof ConfigError)
+            throw error;
         // No `entries` table (or otherwise unreadable) — cannot serve.
         return false;
     }
@@ -220,28 +193,6 @@ function indexCanServeStash(stashDir) {
             closeDatabase(db);
     }
 }
-async function runInlineReindex(stashDir, options = {}) {
-    const { akmIndex } = await import("./indexer.js");
-    const startedMs = Date.now();
-    const response = await akmIndex({
-        stashDir,
-        implicit: true,
-        ...(options.signal ? { signal: options.signal } : {}),
-        ...(options.hydrateSources === false ? { hydrateSources: false } : {}),
-    });
-    // R6: the implicit reindex's cost was previously discarded entirely
-    // (`await akmIndex(...)` and nothing else), making a 27-minute blocking
-    // rebuild invisible to both the operator and the improve result. Fall back
-    // to a wall-clock measurement when the response carries no `timing` block.
-    const durationMs = response.timing?.totalMs ?? Date.now() - startedMs;
-    const timing = response.timing;
-    warnVerbose(`[ensure-index] implicit reindex completed in ${durationMs}ms` +
-        (timing
-            ? ` (walk=${timing.walkMs}ms llm=${timing.llmMs}ms embed=${timing.embedMs}ms finalize=${timing.finalizeMs}ms)`
-            : ""));
-    options.onReindexTiming?.({ durationMs, timing });
-    return true;
-}
 /**
  * Ensure the local index exists and can serve the caller.
  *
@@ -262,24 +213,32 @@ export async function ensureIndex(stashDir, options = {}) {
     // §11.5: warn (once) if the configured bundle ids drifted from the persisted
     // index prefixes (hand-renamed bundle key) BEFORE any rebuild could re-mint.
     warnOnBundleRenameDrift();
-    if (options.mode === "blocking") {
-        // Blocking callers (improve's planning preflight) are a sanctioned
-        // materialization point — hydrate cache-backed sources as usual.
-        if (!isIndexStale(stashDir))
-            return false;
-        return runInlineReindex(stashDir, {
-            ...(options.signal ? { signal: options.signal } : {}),
-            ...(options.onReindexTiming ? { onReindexTiming: options.onReindexTiming } : {}),
-        });
-    }
-    // Background = the READ path (`show` auto-index): query time must never clone/
-    // pull/fetch (spec §14.3 / D11). Build from already-materialized content only;
-    // absent source caches are skipped with a warning, not fetched.
-    if (indexCanServeStash(stashDir))
+    const blocking = options.mode === "blocking";
+    if (indexCanServeStash(stashDir, { requireFresh: blocking }))
         return false;
-    return runInlineReindex(stashDir, {
+    const { akmIndex } = await import("./indexer.js");
+    const startedMs = Date.now();
+    const response = await akmIndex({
+        stashDir,
+        implicit: true,
         ...(options.signal ? { signal: options.signal } : {}),
-        hydrateSources: false,
-        ...(options.onReindexTiming ? { onReindexTiming: options.onReindexTiming } : {}),
+        // Blocking callers (improve's planning preflight) are a sanctioned
+        // materialization point and hydrate cache-backed sources as usual. The
+        // background READ path (`show` auto-index) must never clone/pull/fetch at
+        // query time (spec §14.3 / D11): it builds from already-materialized
+        // content, and absent source caches are skipped with a warning.
+        ...(blocking ? {} : { hydrateSources: false }),
     });
+    // R6: the implicit reindex's cost was previously discarded entirely
+    // (`await akmIndex(...)` and nothing else), making a 27-minute blocking
+    // rebuild invisible to both the operator and the improve result. Fall back
+    // to a wall-clock measurement when the response carries no `timing` block.
+    const durationMs = response.timing?.totalMs ?? Date.now() - startedMs;
+    const timing = response.timing;
+    warnVerbose(`[ensure-index] implicit reindex completed in ${durationMs}ms` +
+        (timing
+            ? ` (walk=${timing.walkMs}ms llm=${timing.llmMs}ms embed=${timing.embedMs}ms finalize=${timing.finalizeMs}ms)`
+            : ""));
+    options.onReindexTiming?.({ durationMs, timing });
+    return true;
 }