akm-cli 0.9.0-rc.2 → 0.9.0-rc.4

package/dist/indexer/index-writer-lock.js

@@ -1,6 +1,7 @@
 // This Source Code Form is subject to the terms of the Mozilla Public
 // License, v. 2.0. If a copy of the MPL was not distributed with this
 // file, You can obtain one at https://mozilla.org/MPL/2.0/.
+import { AsyncLocalStorage } from "node:async_hooks";
 import fs from "node:fs";
 import path from "node:path";
 import { createLockPayload, probeLock, reclaimStaleLock, releaseLock, tryAcquireLockSync, } from "../core/file-lock.js";
@@ -9,7 +10,7 @@ import { getDbPath, getIndexWriterLockPath } from "../core/paths.js";
 const INDEX_WRITER_LOCK_STALE_AFTER_MS = 12 * 60 * 60 * 1000;
 const INDEX_WRITER_WAIT_MS = 100;
 const DEFAULT_INDEX_WRITER_MAX_WAIT_MS = 10 * 60 * 1000;
-const heldLocks = new Map();
+const leaseContext = new AsyncLocalStorage();
 function buildPayload(purpose) {
     return createLockPayload({
         purpose,
@@ -25,29 +26,20 @@ function throwIfAborted(signal) {
         return;
     throw signal.reason instanceof Error ? signal.reason : new Error("index writer wait aborted");
 }
-function releaseHeldLock(lockPath) {
-    const held = heldLocks.get(lockPath);
-    if (!held)
-        return;
-    held.depth -= 1;
-    if (held.depth > 0)
-        return;
-    heldLocks.delete(lockPath);
-    process.off("exit", held.exitHandler);
-    releaseLock(held.ownership);
-}
-function retainHeldLock(lockPath, ownership) {
-    const existing = heldLocks.get(lockPath);
-    if (existing) {
-        existing.depth += 1;
-        return { lockPath, release: () => releaseHeldLock(lockPath) };
-    }
-    if (!ownership)
-        throw new Error(`Missing ownership for index writer lock at ${lockPath}.`);
+function createLease(lockPath, ownership) {
     const exitHandler = () => releaseLock(ownership);
     process.on("exit", exitHandler);
-    heldLocks.set(lockPath, { depth: 1, exitHandler, ownership });
-    return { lockPath, release: () => releaseHeldLock(lockPath) };
+    let released = false;
+    return {
+        lockPath,
+        release: () => {
+            if (released)
+                return;
+            released = true;
+            process.off("exit", exitHandler);
+            releaseLock(ownership);
+        },
+    };
 }
 export async function acquireIndexWriterLease(options) {
     const mode = options.mode ?? "wait";
@@ -61,14 +53,10 @@ export async function acquireIndexWriterLease(options) {
         const releaseBarrier = tryAcquireMaintenanceBarrier();
         if (releaseBarrier) {
             try {
-                if (heldLocks.has(lockPath)) {
-                    options.onAcquired?.({ waitedMs: Date.now() - startedAt });
-                    return retainHeldLock(lockPath);
-                }
                 const ownership = tryAcquireLockSync(lockPath, buildPayload(options.purpose));
                 if (ownership) {
                     options.onAcquired?.({ waitedMs: Date.now() - startedAt });
-                    return retainHeldLock(lockPath, ownership);
+                    return createLease(lockPath, ownership);
                 }
                 const probe = probeLock(lockPath, { staleAfterMs: INDEX_WRITER_LOCK_STALE_AFTER_MS });
                 if (probe.state === "stale") {
@@ -97,16 +85,29 @@ export async function acquireIndexWriterLease(options) {
     }
 }
 export async function withIndexWriterLease(options, run) {
-    const lease = await acquireIndexWriterLease(options);
-    if (!lease) {
-        throw new Error(`index writer lease unavailable for ${options.purpose}`);
-    }
-    try {
-        return await run();
-    }
-    finally {
-        lease.release();
-    }
+    const lockPath = getIndexWriterLockPath();
+    const inherited = leaseContext.getStore();
+    if (inherited?.has(lockPath))
+        return run();
+    const context = inherited ?? new Set();
+    const execute = async () => {
+        const lease = await acquireIndexWriterLease(options);
+        if (!lease)
+            throw new Error(`index writer lease unavailable for ${options.purpose}`);
+        context.add(lockPath);
+        try {
+            return await run();
+        }
+        finally {
+            context.delete(lockPath);
+            lease.release();
+        }
+    };
+    return inherited ? execute() : leaseContext.run(context, execute);
+}
+/** Asset writes and index rebuilds share one lease so scans cannot publish stale snapshots. */
+export function withAssetMutationLease(purpose, run) {
+    return withIndexWriterLease({ purpose }, run);
 }
 export function probeIndexWriterLease() {
     return probeLock(getIndexWriterLockPath(), { staleAfterMs: INDEX_WRITER_LOCK_STALE_AFTER_MS });

package/dist/indexer/index-written-assets.js

@@ -24,7 +24,8 @@ import path from "node:path";
 import { getDbPath } from "../core/paths.js";
 import { warnVerbose } from "../core/warn.js";
 import { takeWorkflowDocument } from "../workflows/runtime/document-cache.js";
-import { closeDatabase, getEntryCount, openExistingDatabase, rebuildFts, upsertEntry, upsertWorkflowDocument, } from "./db/db.js";
+import { closeDatabase, deleteEntriesByIds, getEntryCount, openExistingDatabase, rebuildFts, upsertEntry, upsertWorkflowDocument, } from "./db/db.js";
+import { withIndexWriterLease } from "./index-writer-lock.js";
 import { generateMetadataFlat } from "./passes/metadata.js";
 import { buildSearchText } from "./search/search-fields.js";
 /**
@@ -47,68 +48,84 @@ export const WRITE_PATH_INDEX_BUSY_TIMEOUT_MS = 5_000;
  * first read (`ensureIndex`) or an explicit `akm index`, which also cover
  * embeddings and the other passes this fast path skips.
  */
-export async function indexWrittenAssets(stashDir, filePaths) {
+export async function indexWrittenAssets(stashDir, filePaths, options = {}) {
     try {
-        const dbPath = getDbPath();
-        if (!fs.existsSync(dbPath))
-            return;
-        // The full walk never descends into dot-directories (they hold state like
-        // `.meta/`, `.stash.json`), and `shouldIndexStashFile` relies on the walker
-        // for that — mirror it here so this fast path indexes exactly what a full
-        // run would.
-        const files = filePaths.filter((f) => {
-            if (!fs.existsSync(f))
-                return false;
-            const rel = path.relative(stashDir, f);
-            return !rel.split(/[\\/]+/).some((segment) => segment.startsWith("."));
-        });
-        if (files.length === 0)
-            return;
-        // Generate metadata BEFORE opening the DB so the write window stays
-        // short. One call per file keeps the entry↔path pairing exact.
-        const pairs = [];
-        for (const file of files) {
-            const generated = await generateMetadataFlat(stashDir, [file]);
-            const entry = generated.entries[0];
-            // Workflows also carry a workflow_documents side-table upsert — handled
-            // below, mirroring the full walk — since `akm mv` rewrites citer files
-            // that can be workflows.
-            if (entry)
-                pairs.push({ file, entry });
-        }
-        if (pairs.length === 0)
-            return;
-        const db = openExistingDatabase(dbPath);
-        try {
-            db.exec(`PRAGMA busy_timeout = ${WRITE_PATH_INDEX_BUSY_TIMEOUT_MS}`);
-            if (getEntryCount(db) === 0)
-                return;
-            for (const { file, entry } of pairs) {
-                const entryKey = `${stashDir}:${entry.type}:${entry.name}`;
-                let entryWithSize = entry;
-                try {
-                    entryWithSize = { ...entry, fileSize: fs.statSync(file).size };
+        return await withIndexWriterLease({ purpose: "index-written-assets" }, async () => {
+            if (options.recoverMoves !== false) {
+                const { recoverInterruptedMoveTransactions } = await import("../commands/mv-cli.js");
+                await recoverInterruptedMoveTransactions(stashDir);
+            }
+            const dbPath = getDbPath();
+            if (!fs.existsSync(dbPath))
+                return true;
+            // The full walk never descends into dot-directories (they hold state like
+            // `.meta/`, `.stash.json`), and `shouldIndexStashFile` relies on the walker
+            // for that — mirror it here so this fast path indexes exactly what a full
+            // run would.
+            const files = filePaths.filter((f) => {
+                const rel = path.relative(stashDir, f);
+                return !rel.split(/[\\/]+/).some((segment) => segment.startsWith("."));
+            });
+            if (files.length === 0)
+                return true;
+            // Generate metadata BEFORE opening the DB so the write window stays
+            // short. One call per file keeps the entry↔path pairing exact.
+            const pairs = [];
+            const unindexable = new Set();
+            for (const file of files) {
+                if (!fs.existsSync(file)) {
+                    unindexable.add(file);
+                    continue;
                 }
-                catch {
-                    // stat raced a delete — index without the size, like the full walk does.
+                const generated = await generateMetadataFlat(stashDir, [file]);
+                const entry = generated.entries[0];
+                // Workflows also carry a workflow_documents side-table upsert — handled
+                // below, mirroring the full walk — since `akm mv` rewrites citer files
+                // that can be workflows.
+                if (entry)
+                    pairs.push({ file, entry });
+                else
+                    unindexable.add(file);
+            }
+            const db = openExistingDatabase(dbPath);
+            try {
+                db.exec(`PRAGMA busy_timeout = ${WRITE_PATH_INDEX_BUSY_TIMEOUT_MS}`);
+                if (getEntryCount(db) === 0)
+                    return true;
+                for (const file of unindexable) {
+                    const rows = db.prepare("SELECT id FROM entries WHERE file_path = ?").all(file);
+                    deleteEntriesByIds(db, rows.map((row) => row.id));
                 }
-                const entryId = upsertEntry(db, entryKey, path.dirname(file), file, stashDir, entryWithSize, buildSearchText(entry));
-                if (entry.type === "workflow") {
-                    // Same contract as the full walk (indexer.ts): the renderer cached
-                    // the parsed document during metadata generation; persist it so the
-                    // workflow runtime never sees an entry without its document.
-                    const doc = takeWorkflowDocument(entry);
-                    if (doc)
-                        upsertWorkflowDocument(db, entryId, doc, fs.readFileSync(file));
+                for (const { file, entry } of pairs) {
+                    const entryKey = `${stashDir}:${entry.type}:${entry.name}`;
+                    let entryWithSize = entry;
+                    try {
+                        entryWithSize = { ...entry, fileSize: fs.statSync(file).size };
+                    }
+                    catch {
+                        // stat raced a delete — index without the size, like the full walk does.
+                    }
+                    const entryId = upsertEntry(db, entryKey, path.dirname(file), file, stashDir, entryWithSize, buildSearchText(entry));
+                    if (entry.type === "workflow") {
+                        // Same contract as the full walk (indexer.ts): the renderer cached
+                        // the parsed document during metadata generation; persist it so the
+                        // workflow runtime never sees an entry without its document.
+                        const doc = takeWorkflowDocument(entry);
+                        if (doc)
+                            upsertWorkflowDocument(db, entryId, doc, fs.readFileSync(file));
+                    }
                 }
+                if (pairs.length > 0 || unindexable.size > 0)
+                    rebuildFts(db, { incremental: true });
             }
-            rebuildFts(db, { incremental: true });
-        }
-        finally {
-            closeDatabase(db);
-        }
+            finally {
+                closeDatabase(db);
+            }
+            return true;
+        });
     }
     catch (error) {
         warnVerbose("Write-path index update skipped (asset appears after the next full index):", error instanceof Error ? error.message : String(error));
+        return false;
     }
 }

package/dist/indexer/indexer.js

@@ -155,7 +155,7 @@ async function runFinalizePhase(ctx) {
     ctx.timing.tFtsEnd = Date.now();
     // Re-link detached usage_events and recompute utility scores.
     onProgress({ phase: "finalize", message: "Relinking usage events." });
-    relinkUsageEvents(db);
+    relinkUsageEvents(db, { sources, defaultStashDir: stashDir });
     onProgress({ phase: "finalize", message: "Recomputing utility scores." });
     recomputeUtilityScores(db);
     // Purge LLM cache entries for assets that no longer exist in the index.
@@ -326,6 +326,10 @@ async function akmIndexReal(options) {
         const sourceCacheEnd = Date.now();
         const allSourceEntries = resolveSourceEntries(stashDir, config);
         const allSourceDirs = allSourceEntries.map((s) => s.path);
+        const { recoverInterruptedMoveTransactions } = await import("../commands/mv-cli.js");
+        for (const sourceDir of new Set([stashDir, ...allSourceDirs])) {
+            await recoverInterruptedMoveTransactions(sourceDir);
+        }
         onProgress({
             phase: "preflight",
             message: `Resolved ${allSourceDirs.length} stash source${allSourceDirs.length === 1 ? "" : "s"}.`,

package/dist/indexer/search/search-source.js

@@ -5,6 +5,7 @@ import fs from "node:fs";
 import path from "node:path";
 import { resolveStashDir } from "../../core/common.js";
 import { getSources, loadConfig } from "../../core/config/config.js";
+import { resolveGitContentRoot } from "../../core/write-source.js";
 import { resolveSourceProviderFactory } from "../../sources/provider-factory.js";
 // Eager side-effect imports so all built-in source providers self-register
 // before resolveEntryContentDir() runs.
@@ -141,8 +142,7 @@ function resolveEntryContentDir(entry) {
     // that subdirectory. This is a content-layout convention, not a provider
     // capability — keep it here.
     if (GIT_STASH_TYPES.has(entry.type)) {
-        const contentDir = path.join(dir, "content");
-        return isValidDirectory(contentDir) ? contentDir : dir;
+        return resolveGitContentRoot(dir);
     }
     return dir;
 }

package/dist/indexer/usage/usage-events.js

@@ -47,8 +47,14 @@ export function getUsageEvents(db, filters) {
         params.push(filters.event_type);
     }
     if (filters?.entry_ref) {
-        conditions.push("entry_ref = ?");
-        params.push(filters.entry_ref);
+        if (filters.entry_ref.includes("//")) {
+            conditions.push("entry_ref = ?");
+            params.push(filters.entry_ref);
+        }
+        else {
+            conditions.push("(entry_ref = ? OR substr(entry_ref, -length(?) - 2) = '//' || ?)");
+            params.push(filters.entry_ref, filters.entry_ref, filters.entry_ref);
+        }
     }
     if (filters?.source) {
         conditions.push("source = ?");

package/dist/integrations/agent/engine-resolution.js

@@ -164,17 +164,24 @@ function lowerAgentEngine(name, engine, config) {
             timeoutMs: hasOwn(engine, "timeoutMs") ? (engine.timeoutMs ?? null) : DEFAULT_AGENT_TIMEOUT_MS,
         };
     }
-    const fallback = resolveLlmEngineUse(config, [{ engine: engine.llmEngine ?? config.defaults?.llmEngine }]);
-    if (!fallback)
-        throw new ConfigError(`SDK engine "${name}" has no fallback LLM engine.`, "LLM_NOT_CONFIGURED");
+    const fallbackName = engine.llmEngine ?? config.defaults?.llmEngine;
+    const fallback = fallbackName
+        ? resolveLlmEngineUse(config, [{ engine: fallbackName }], { optional: true })
+        : undefined;
     return {
         kind: "sdk",
         engine: name,
         profile,
-        fallbackConnection: fallback.connection,
-        ...(fallback.credential ? { fallbackCredential: fallback.credential } : {}),
-        fallbackTimeoutMs: fallback.timeoutMs,
-        timeoutMs: hasOwn(engine, "timeoutMs") ? (engine.timeoutMs ?? null) : fallback.timeoutMs,
+        ...(fallback
+            ? {
+                fallbackConnection: fallback.connection,
+                ...(fallback.credential ? { fallbackCredential: fallback.credential } : {}),
+                fallbackTimeoutMs: fallback.timeoutMs,
+            }
+            : {}),
+        timeoutMs: hasOwn(engine, "timeoutMs")
+            ? (engine.timeoutMs ?? null)
+            : (fallback?.timeoutMs ?? DEFAULT_AGENT_TIMEOUT_MS),
     };
 }
 /** Lower a named engine through the canonical harness platform. */