akm-cli 0.9.1 → 0.9.2-alpha.2

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

@@ -13,25 +13,25 @@
  * the 2026-07 read-path reindex-contention findings §7).
  *
  * This is NOT a general reindex. It upserts exactly the files the caller just
- * wrote: frontmatter/metadata via the shared matcher pipeline, the `entries`
- * row, and an incremental FTS refresh. Embeddings, index-time LLM passes,
- * graph extraction, `builtAt`, and the per-dir walk cache are all deliberately
- * untouched — the next full run heals them (the opportunistic-recovery
- * strategy of the index-consistency ADR).
+ * wrote: frontmatter/metadata via the shared matcher pipeline, the canonical
+ * row with its transactionally owned FTS projection, and vectors for changed
+ * entry IDs when semantic search is enabled. Index-time LLM passes, graph
+ * extraction, `builtAt`, and the per-dir walk cache remain full-index
+ * responsibilities.
  */
 import fs from "node:fs";
 import path from "node:path";
 import { akmAdapter } from "../core/adapter/adapters/akm-adapter.js";
+import { loadConfig } from "../core/config/config.js";
 import { isDataDirUnreadableError } from "../core/errors.js";
 import { isPathAbsent } from "../core/path-access.js";
 import { getDbPath } from "../core/paths.js";
 import { warn, warnVerbose } from "../core/warn.js";
 import { closeDatabase, openExistingDatabase } from "../storage/repositories/index-connection.js";
-import { deleteEntriesByIds, getEntryCount, upsertEntry, upsertWorkflowDocument, } from "../storage/repositories/index-entries-repository.js";
-import { rebuildFts } from "../storage/repositories/index-fts-repository.js";
-import { takeWorkflowDocument } from "../workflows/runtime/document-cache.js";
+import { deleteEntriesByIds, getEntryCount, upsertEntry } from "../storage/repositories/index-entries-repository.js";
 import { withIndexWriterLease } from "./index-writer-lock.js";
 import { deriveEntryProvenance, deriveInstallations } from "./installations.js";
+import { generateEmbeddingsForDb, publishTargetedSemanticStatus } from "./materialize-embeddings.js";
 import { drainDirDocuments } from "./scan/drain-dir.js";
 import { buildSearchText } from "./search/search-fields.js";
 import { buildFileContext } from "./walk/file-context.js";
@@ -88,10 +88,20 @@ export async function indexWrittenAssets(stashDir, filePaths, options = {}) {
                 throw new Error(`Could not derive bundle provenance for ${stashDir}`);
             const pairs = [];
             const unindexable = new Set();
+            const rejectedConceptIds = new Set();
             for (const file of files) {
                 if (!fs.existsSync(file)) {
-                    unindexable.add(file);
-                    continue;
+                    let authoredDanglingSymlink = false;
+                    try {
+                        authoredDanglingSymlink = fs.lstatSync(file).isSymbolicLink();
+                    }
+                    catch {
+                        // A genuinely absent path has no source identity to preflight.
+                    }
+                    if (!authoredDanglingSymlink) {
+                        unindexable.add(file);
+                        continue;
+                    }
                 }
                 const ctx = buildFileContext(stashDir, file);
                 // Hardcoded `akmAdapter` on purpose (owner ruling 2026-07-21): this
@@ -100,11 +110,13 @@ export async function indexWrittenAssets(stashDir, filePaths, options = {}) {
                 // adapter is always the right recognizer here — no per-component
                 // dispatch needed.
                 const drained = drainDirDocuments(akmAdapter, component, [ctx]);
+                for (const rejectedPath of drained.rejectedPaths)
+                    unindexable.add(rejectedPath);
+                for (const conceptId of drained.rejectedConceptIds)
+                    rejectedConceptIds.add(conceptId);
                 const entry = drained.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. A broken workflow drains to zero entries (like
-                // the old skip-with-warning) and is treated as unindexable.
+                // A broken workflow drains to zero entries and is treated as
+                // unindexable; valid peer sources have already compiled to source IR.
                 const conceptId = drained.conceptIdByFile.get(ctx.absPath);
                 if (entry && conceptId)
                     pairs.push({ file, entry, conceptId, contentHash: drained.hashByFile.get(ctx.absPath) });
@@ -116,35 +128,62 @@ export async function indexWrittenAssets(stashDir, filePaths, options = {}) {
                 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));
-                }
-                for (const { file, entry, conceptId, contentHash } of pairs) {
-                    const entryKey = `${stashDir}:${entry.type}:${entry.name}`;
-                    let entryWithSize = entry;
-                    try {
-                        entryWithSize = { ...entry, fileSize: fs.statSync(file).size };
+                const targetEntryIds = new Set();
+                let mutated = false;
+                db.transaction(() => {
+                    const unindexableEntryIds = new Set();
+                    for (const file of unindexable) {
+                        const rows = db
+                            .prepare(`SELECT id FROM entries
+                  WHERE file_path = ?
+                    AND bundle_id = ?
+                    AND adapter_id = ?`)
+                            .all(file, component.id, component.adapter);
+                        for (const row of rows)
+                            unindexableEntryIds.add(row.id);
                     }
-                    catch {
-                        // stat raced a delete — index without the size, like the full walk does.
+                    for (const conceptId of rejectedConceptIds) {
+                        const itemRef = `${component.id}//${conceptId}`;
+                        const rows = db
+                            .prepare(`SELECT id FROM entries
+                  WHERE bundle_id = ? AND adapter_id = ?
+                    AND type = 'workflow'
+                    AND (concept_id = ? OR item_ref = ?)`)
+                            .all(component.id, component.adapter, conceptId, itemRef);
+                        for (const row of rows)
+                            unindexableEntryIds.add(row.id);
                     }
-                    // Real provenance (F4a M-core-2 item 5): populate item_ref/content_hash
-                    // via the SAME derivation the full-index writer uses, so a write-path
-                    // row is never a NULL-item_ref straggler.
-                    const provenance = deriveEntryProvenance({ bundleId: component.id, componentId: component.id, adapterId: component.adapter }, entry.type, entry.name, conceptId);
-                    const entryId = upsertEntry(db, entryKey, path.dirname(file), file, stashDir, entryWithSize, buildSearchText(entry), provenance, contentHash);
-                    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));
+                    deleteEntriesByIds(db, [...unindexableEntryIds]);
+                    mutated ||= unindexableEntryIds.size > 0;
+                    for (const { file, entry, conceptId, contentHash } of pairs) {
+                        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.
+                        }
+                        // Real provenance (F4a M-core-2 item 5): populate item_ref/content_hash
+                        // via the SAME derivation the full-index writer uses, so a write-path
+                        // row is never a NULL-item_ref straggler.
+                        const provenance = deriveEntryProvenance({ bundleId: component.id, componentId: component.id, adapterId: component.adapter }, entry.type, entry.name, conceptId);
+                        // A materialized file has one current owner. If a targeted write is
+                        // the ownership handoff (for example an explicitly named bundle
+                        // replacing an earlier path-derived bootstrap identity), remove the
+                        // superseded physical-path row before publishing the canonical ref.
+                        const supersededIds = db
+                            .prepare("SELECT id FROM entries WHERE file_path = ? AND item_ref <> ?")
+                            .all(file, provenance.itemRef);
+                        deleteEntriesByIds(db, supersededIds.map((row) => row.id));
+                        targetEntryIds.add(upsertEntry(db, file, entryWithSize, buildSearchText(entry), provenance, contentHash));
+                        mutated = true;
                     }
+                })();
+                if (mutated) {
+                    const config = loadConfig();
+                    const embeddingResult = await generateEmbeddingsForDb(db, config, () => { }, undefined, [...targetEntryIds]);
+                    publishTargetedSemanticStatus(db, config, embeddingResult);
                 }
-                if (pairs.length > 0 || unindexable.size > 0)
-                    rebuildFts(db, { incremental: true });
             }
             finally {
                 closeDatabase(db);