akm-cli 0.9.0-beta.11 → 0.9.0-beta.26

package/dist/llm/embedder.js

@@ -2,7 +2,7 @@
 // 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 { embedCacheKey, getCachedEmbedding, setCachedEmbedding } from "./embedders/cache.js";
-import { isTransformersAvailable, LocalEmbedder } from "./embedders/local.js";
+import { DEFAULT_LOCAL_MODEL, isTransformersAvailable, LocalEmbedder } from "./embedders/local.js";
 import { hasRemoteEndpoint, RemoteEmbedder } from "./embedders/remote.js";
 // ── Re-exports (public API) ─────────────────────────────────────────────────
 export { clearEmbeddingCache } from "./embedders/cache.js";
@@ -52,7 +52,8 @@ export async function embed(text, embeddingConfig, signal) {
 /**
  * Generate embeddings for multiple texts in batch.
  * Uses the OpenAI-compatible batch API for remote endpoints (batches of 100).
- * Falls back to sequential embedding for the local transformer pipeline.
+ * Uses the LocalEmbedder.embedBatch path for the local transformer pipeline,
+ * which processes texts in chunks of 32 for genuine batched inference.
  */
 export async function embedBatch(texts, embeddingConfig, signal) {
     if (texts.length === 0)
@@ -60,8 +61,13 @@ export async function embedBatch(texts, embeddingConfig, signal) {
     if (embeddingConfig && hasRemoteEndpoint(embeddingConfig)) {
         return new RemoteEmbedder(embeddingConfig).embedBatch(texts, signal);
     }
-    // Local transformer: process sequentially (pipeline handles one at a time)
+    // Local transformer: use the batched path (chunks of 32 via LocalEmbedder).
+    // When a localModel override is set we cannot share the singleton (which uses
+    // the default model), so fall back to per-text embedWithModel in that case.
     const localModel = embeddingConfig?.localModel;
+    if (!localModel) {
+        return getLocalEmbedder().embedBatch(texts, signal);
+    }
     const results = [];
     for (const text of texts) {
         if (signal?.aborted) {
@@ -77,6 +83,24 @@ export async function embedBatch(texts, embeddingConfig, signal) {
 // facade and its `@huggingface/transformers` import chain. Re-export
 // preserves the existing public API.
 export { cosineSimilarity } from "./embedders/types.js";
+// ── Model ID resolution ─────────────────────────────────────────────────────
+/**
+ * Derive a stable string identifier for the embedding model in use.
+ * This is the `model_id` stored in `body_embeddings` (and used for the
+ * drop-all-on-mismatch purge when the model changes).
+ *
+ * Rules:
+ *   - Remote endpoint: use `config.model` (the API-level model name).
+ *   - Local transformers: use `config.localModel ?? DEFAULT_LOCAL_MODEL`.
+ *   - No config: use `DEFAULT_LOCAL_MODEL` (the shared singleton model).
+ */
+export function resolveEmbeddingModelId(embeddingConfig) {
+    if (!embeddingConfig)
+        return DEFAULT_LOCAL_MODEL;
+    if (hasRemoteEndpoint(embeddingConfig))
+        return embeddingConfig.model ?? "remote";
+    return embeddingConfig.localModel ?? DEFAULT_LOCAL_MODEL;
+}
 // ── Availability check ──────────────────────────────────────────────────────
 /**
  * Check whether embedding is available with a detailed reason on failure.

package/dist/llm/embedders/local.js

@@ -19,8 +19,24 @@ import { getDirname, resolveModule } from "../../runtime.js";
  * `all-MiniLM-L6-v2` at the same 384-dimension footprint.
  */
 export const DEFAULT_LOCAL_MODEL = "Xenova/bge-small-en-v1.5";
+/** Type-guard: true when the value looks like a batch Tensor (has .dims). */
+function isBatchTensor(v) {
+    return (v !== null &&
+        typeof v === "object" &&
+        "data" in v &&
+        "dims" in v &&
+        Array.isArray(v.dims) &&
+        v.dims.length >= 2);
+}
 const LOCAL_EMBEDDER_DTYPE = "fp32";
 const LOCAL_EMBEDDER_FALLBACK_DTYPE = "auto";
+/**
+ * Maximum texts per batch for the local transformers pipeline. The pipeline
+ * can run genuine batched inference over a string array; 32 is a safe default
+ * that fits well inside most model context budgets while providing 10–50×
+ * throughput improvement over one-at-a-time calls on the cold minority.
+ */
+const LOCAL_BATCH_SIZE = 32;
 /**
  * Return the local model name that will be used for embedding.
  * When `overrideModel` is provided it takes precedence; otherwise
@@ -77,15 +93,63 @@ export class LocalEmbedder {
         }
         return this.embedWithModel(text, this.defaultModel);
     }
+    /**
+     * Embed a batch of texts. Processes in chunks of `LOCAL_BATCH_SIZE` (32) so
+     * the transformers pipeline can run genuine batched inference rather than one
+     * call per text. Falls back to one-at-a-time if the pipeline does not support
+     * array input (older versions of @huggingface/transformers). Each chunk is
+     * checked against the AbortSignal between calls.
+     */
     async embedBatch(texts, signal) {
         if (texts.length === 0)
             return [];
+        if (signal?.aborted) {
+            throw signal.reason instanceof Error ? signal.reason : new Error("embedding interrupted");
+        }
+        const pipeline = await this.getPipeline(this.defaultModel);
         const results = [];
-        for (const text of texts) {
+        for (let i = 0; i < texts.length; i += LOCAL_BATCH_SIZE) {
             if (signal?.aborted) {
                 throw signal.reason instanceof Error ? signal.reason : new Error("embedding interrupted");
             }
-            results.push(await this.embedWithModel(text, this.defaultModel));
+            const chunk = texts.slice(i, i + LOCAL_BATCH_SIZE);
+            try {
+                // @huggingface/transformers feature-extraction pipeline accepts a
+                // string[] and returns a batch Tensor (NOT an Array<{data}>).
+                // The Tensor has .data (flat Float32Array, length = batch * dim) and
+                // .dims = [batch, dim]. Slice .data into per-row vectors using .dims.
+                const batchResult = await pipeline(chunk, {
+                    pooling: "mean",
+                    normalize: true,
+                });
+                if (isBatchTensor(batchResult)) {
+                    const dim = batchResult.dims[1];
+                    for (let row = 0; row < chunk.length; row++) {
+                        results.push(Array.from(batchResult.data.subarray(row * dim, (row + 1) * dim)));
+                    }
+                }
+                else if (Array.isArray(batchResult)) {
+                    // Older versions of @huggingface/transformers returned Array<{data}>.
+                    for (const r of batchResult) {
+                        results.push(Array.from(r.data));
+                    }
+                }
+                else {
+                    // Single-text result returned for a chunk — should not happen for
+                    // string[] input, but handle defensively.
+                    throw new Error("unexpected pipeline return shape for batch input");
+                }
+            }
+            catch {
+                // Fallback: process one-at-a-time (older pipeline versions or mismatched
+                // return type). Fail-open per text: a single failure aborts the chunk.
+                for (const text of chunk) {
+                    if (signal?.aborted) {
+                        throw signal.reason instanceof Error ? signal.reason : new Error("embedding interrupted");
+                    }
+                    results.push(await this.embedWithModel(text, this.defaultModel));
+                }
+            }
         }
         return results;
     }

package/dist/llm/graph-extract.js

@@ -20,6 +20,7 @@
  * the connection via `resolveIndexPassLLM("graph", config)` and pass it
  * straight through.
  */
+import systemPromptTemplate from "../assets/prompts/graph-extract-system.md" with { type: "text" };
 import userPromptTemplate from "../assets/prompts/graph-extract-user-prompt.md" with { type: "text" };
 import { toErrorMessage } from "../core/common.js";
 import { warn, warnVerbose } from "../core/warn.js";
@@ -41,7 +42,7 @@ const NON_ARRAY_BATCH_DISABLE_THRESHOLD = 2;
 const MAX_ENTITIES_PER_ASSET = 32;
 /** Hard cap on relations returned per asset. */
 const MAX_RELATIONS_PER_ASSET = 32;
-const SYSTEM_PROMPT = "You extract a knowledge graph from developer notes. Return ONLY valid JSON — no prose, no markdown fences, no preamble.";
+const SYSTEM_PROMPT = systemPromptTemplate;
 const USER_PROMPT_PREFIX = userPromptTemplate
     .replace("{{MAX_ENTITIES}}", String(MAX_ENTITIES_PER_ASSET))
     .replace("{{MAX_RELATIONS}}", String(MAX_RELATIONS_PER_ASSET));

package/dist/llm/memory-infer.js

@@ -18,20 +18,16 @@
  * the connection via `resolveIndexPassLLM("memory", config)` and pass it
  * straight through.
  */
+import memoryInferSystemPrompt from "../assets/prompts/memory-infer-system.md" with { type: "text" };
+import memoryInferUserPrompt from "../assets/prompts/memory-infer-user.md" with { type: "text" };
 import { toErrorMessage } from "../core/common.js";
 import { warn } from "../core/warn.js";
 import { chatCompletion, LlmCallError, parseEmbeddedJsonResponse } from "./client.js";
 import { tryLlmFeature } from "./feature-gate.js";
 /** Hard cap on body chars sent to the model — pragmatic and matches `runLlmEnrich`. */
 const MAX_BODY_CHARS = 4000;
-const SYSTEM_PROMPT = "You compress a developer memory into one high-signal derived memory for later retrieval. " +
-    "Return only valid JSON. No prose outside the JSON object. No markdown fences.";
-const USER_PROMPT_PREFIX = `Compress the memory below into one derived memory. Output ONLY JSON:
-{"title":"short title string","description":"one sentence summary string","tags":["tag1","tag2"],"searchHints":["search phrase 1","search phrase 2"],"content":"2-3 sentence compressed body preserving key facts verbatim"}
-Rules: be specific, no vague generalizations, preserve key facts (names/versions/paths/config keys verbatim), merge related points, 3-8 tags, 3-6 searchHints. The content field must be a plain string with 2-3 sentences.
-
-Memory:
-`;
+const SYSTEM_PROMPT = memoryInferSystemPrompt;
+const USER_PROMPT_PREFIX = memoryInferUserPrompt;
 /**
  * Strict JSON Schema for the derived-memory payload. Sent to providers that
  * opt in via `LlmConnectionConfig.supportsJsonSchema = true`; the client

package/dist/llm/metadata-enhance.js

@@ -1,9 +1,17 @@
 // 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/.
+/**
+ * LLM-driven metadata enhancement for stash entries.
+ *
+ * Split out of `llm.ts` so the higher-level workflow (prompting the LLM to
+ * improve descriptions/tags/searchHints) lives separately from the low-level
+ * transport client in `client.ts`.
+ */
+import metadataEnhanceSystemPrompt from "../assets/prompts/metadata-enhance-system.md" with { type: "text" };
 import { chatCompletion, parseJsonResponse } from "./client.js";
 import { tryLlmFeature } from "./feature-gate.js";
-const SYSTEM_PROMPT = `You are a metadata generator for a developer asset registry. Given a script/skill/command/agent entry, generate improved metadata. Respond with ONLY valid JSON, no markdown fencing.`;
+const SYSTEM_PROMPT = metadataEnhanceSystemPrompt;
 /**
  * Use an LLM to enhance a stash entry's metadata: improve description,
  * generate searchHints, and suggest tags.

package/dist/output/shapes/curate.js

@@ -5,7 +5,7 @@ import { capDescription, NORMAL_DESCRIPTION_LIMIT, pickFields } from "./helpers.
 // Curation is a small, high-signal top-N. Even at `brief` we keep `followUp`
 // (the actionable `akm show <ref>` command) and `reason` (why this asset was
 // selected) — these are the point of curate, unlike a bulk search listing.
-const BRIEF_FIELDS = ["source", "type", "name", "ref", "id", "followUp", "reason"];
+const BRIEF_FIELDS = ["source", "type", "name", "ref", "id", "supportRefs", "followUp", "reason"];
 const NORMAL_FIELDS = [
     "source",
     "type",
@@ -17,12 +17,24 @@ const NORMAL_FIELDS = [
     "keys",
     "parameters",
     "run",
+    "supportRefs",
     "followUp",
     "reason",
     "score",
 ];
 // Agent shape: the minimal field set an LLM needs to decide and act.
-const AGENT_FIELDS = ["source", "type", "name", "ref", "id", "description", "followUp", "reason", "score"];
+const AGENT_FIELDS = [
+    "source",
+    "type",
+    "name",
+    "ref",
+    "id",
+    "description",
+    "supportRefs",
+    "followUp",
+    "reason",
+    "score",
+];
 function shapeCurateItem(item, detail, shape) {
     if (shape === "agent") {
         return capDescription(pickFields(item, AGENT_FIELDS), NORMAL_DESCRIPTION_LIMIT);

package/dist/output/text/helpers.js

@@ -1005,6 +1005,15 @@ export function formatCuratePlain(r, detail) {
             lines.push(`  run: ${String(item.run)}`);
         if (item.followUp)
             lines.push(`  show: ${String(item.followUp)}`);
+        if (Array.isArray(item.supportRefs) && item.supportRefs.length > 0) {
+            for (const support of item.supportRefs) {
+                if (!support.ref)
+                    continue;
+                const label = typeof support.type === "string" ? `[${support.type}] ` : "";
+                const why = typeof support.reason === "string" ? ` — ${support.reason}` : "";
+                lines.push(`  support: ${label}${String(support.ref)}${why}`);
+            }
+        }
         if (detail !== "brief" && item.reason)
             lines.push(`  why: ${String(item.reason)}`);
     }

package/dist/runtime.js

@@ -22,7 +22,7 @@
  */
 import { spawn as nodeSpawn, spawnSync as nodeSpawnSync } from "node:child_process";
 import { createHash } from "node:crypto";
-import { createWriteStream } from "node:fs";
+import { createWriteStream, statfsSync } from "node:fs";
 import { createRequire } from "node:module";
 import path from "node:path";
 import { Readable } from "node:stream";
@@ -200,6 +200,30 @@ export function resolveModule(spec, from) {
 export function getDirname(importMetaUrl) {
     return path.dirname(fileURLToPath(importMetaUrl));
 }
+// ── Filesystem type probe ─────────────────────────────────────────────────────
+/**
+ * Best-effort filesystem-type probe: return the numeric `f_type` magic of the
+ * filesystem backing `path`, or `undefined` on any error (ENOENT/EPERM/
+ * unsupported). Used (via injection) by the SQLite journal-mode network-FS
+ * fallback (#628).
+ *
+ * This is a runtime primitive (a `statfs` filesystem-type probe) and therefore
+ * lives here, per the runtime boundary, even though it uses only `node:fs`. The
+ * "magic-number → is-network" classification stays a pure helper elsewhere.
+ *
+ * `fs.statfsSync` is a stable `node:fs` API (Node ≥ 18.15) and is implemented
+ * under Bun as well. It THROWS ENOENT on a non-existent path, so callers should
+ * probe an already-created directory — the swallowed error simply yields
+ * `undefined` (treated as "not network").
+ */
+export function statfsType(path) {
+    try {
+        return statfsSync(path).type;
+    }
+    catch {
+        return undefined;
+    }
+}
 // ── Sleep ───────────────────────────────────────────────────────────────────
 /**
  * Block the current thread for `ms` without busy-spinning. On Bun uses the real