akm-cli 0.9.0-beta.53 → 0.9.0-beta.55

package/dist/scripts/migrations/import-fs-improve-runs-to-db.js

@@ -53,12 +53,16 @@ function appendToLogFile(level, args) {
   }
 }
 function warn(...args) {
+  if (sinkOverride) {
+    sinkOverride("warn", args);
+    return;
+  }
   appendToLogFile("WARN", args);
   if (!quiet) {
     console.warn(...args);
   }
 }
-var quiet = false, logFilePath;
+var quiet = false, logFilePath, sinkOverride;
 var init_warn = () => {};
 
 // node_modules/dotenv/lib/main.js
@@ -8608,8 +8612,8 @@ function resolveJournalMode(raw) {
   warnInvalidJournalModeOnce(raw);
   return "WAL";
 }
-function resolveConfiguredJournalMode() {
-  return resolveJournalMode(process.env.AKM_SQLITE_JOURNAL_MODE);
+function resolveConfiguredJournalMode(env = process.env) {
+  return resolveJournalMode(env.AKM_SQLITE_JOURNAL_MODE);
 }
 function warnInvalidJournalModeOnce(raw) {
   if (warnedInvalid)
@@ -8635,7 +8639,7 @@ function isNetworkFilesystem(fsType) {
   return NETWORK_FS_MAGICS.has(fsType);
 }
 function applyStandardPragmas(db, opts = {}) {
-  let mode = resolveConfiguredJournalMode();
+  let mode = resolveConfiguredJournalMode(opts.env);
   if (mode === "WAL" && opts.dataDir) {
     const probe = opts.fsTypeProbe ?? statfsType;
     if (isNetworkFilesystem(probe(opts.dataDir))) {
@@ -8672,48 +8676,8 @@ function openManagedDatabase(spec) {
   return db;
 }
 
-// src/core/assert.ts
-function assertNever(x, context) {
-  let serialized;
-  try {
-    serialized = JSON.stringify(x);
-  } catch {
-    serialized = String(x);
-  }
-  if (serialized === undefined) {
-    serialized = String(x);
-  }
-  const where = context ? ` (${context})` : "";
-  throw new Error(`Unexpected value reached assertNever${where}: ${serialized}`);
-}
-
-// src/core/improve-types.ts
-function classifyImproveAction(mode) {
-  switch (mode) {
-    case "reflect":
-    case "distill":
-    case "memory-inference":
-    case "graph-extraction":
-      return "accepted";
-    case "reflect-cooldown":
-    case "reflect-skipped":
-    case "distill-skipped":
-      return "skipped";
-    case "reflect-guard-rejected":
-      return "rejected";
-    case "reflect-failed":
-    case "error":
-      return "error";
-    case "memory-prune":
-      return "noop";
-    default:
-      return assertNever(mode);
-  }
-}
-
 // src/core/state-db.ts
 init_paths();
-init_warn();
 
 // src/storage/engines/sqlite-migrations.ts
 function ensureMigrationsTable(db) {
@@ -9178,6 +9142,47 @@ function getStateDbPath() {
 function openStateDatabase(dbPath) {
   return openManagedDatabase({ path: dbPath ?? getStateDbPath(), init: runMigrations2 });
 }
+
+// src/core/assert.ts
+function assertNever(x, context) {
+  let serialized;
+  try {
+    serialized = JSON.stringify(x);
+  } catch {
+    serialized = String(x);
+  }
+  if (serialized === undefined) {
+    serialized = String(x);
+  }
+  const where = context ? ` (${context})` : "";
+  throw new Error(`Unexpected value reached assertNever${where}: ${serialized}`);
+}
+
+// src/core/improve-types.ts
+function classifyImproveAction(mode) {
+  switch (mode) {
+    case "reflect":
+    case "distill":
+    case "memory-inference":
+    case "graph-extraction":
+      return "accepted";
+    case "reflect-cooldown":
+    case "reflect-skipped":
+    case "distill-skipped":
+      return "skipped";
+    case "reflect-guard-rejected":
+      return "rejected";
+    case "reflect-failed":
+    case "error":
+      return "error";
+    case "memory-prune":
+      return "noop";
+    default:
+      return assertNever(mode);
+  }
+}
+
+// src/storage/repositories/improve-runs-repository.ts
 function computeImproveRunMetrics(result) {
   const plannedCount = Array.isArray(result.plannedRefs) ? result.plannedRefs.length : 0;
   const actions = Array.isArray(result.actions) ? result.actions : [];

package/dist/setup/detect.js

@@ -14,6 +14,11 @@ import { defaultWhich } from "../integrations/agent/detect.js";
 import { SESSION_LOG_HARNESSES } from "../integrations/harnesses/index.js";
 import { spawn } from "../runtime.js";
 import { detectHarnessConfigs } from "./harness-config-import.js";
+let detectOverrides;
+/** TEST-ONLY. Swap the network/host probes; pass undefined to restore. */
+export function _setDetectForTests(fakes) {
+    detectOverrides = fakes;
+}
 // ── Ollama Detection ────────────────────────────────────────────────────────
 const OLLAMA_BASE = "http://localhost:11434";
 /**
@@ -23,6 +28,8 @@ const OLLAMA_BASE = "http://localhost:11434";
  * via subprocess. Returns available models sorted alphabetically.
  */
 export async function detectOllama() {
+    if (detectOverrides?.detectOllama)
+        return detectOverrides.detectOllama();
     const result = { available: false, models: [], endpoint: OLLAMA_BASE };
     // Try HTTP API first
     try {
@@ -120,6 +127,8 @@ const AGENT_PLATFORMS = SESSION_LOG_HARNESSES.filter((h) => h.setupDetectionDir)
  * Supports both HOME (Unix) and USERPROFILE (Windows).
  */
 export function detectAgentPlatforms() {
+    if (detectOverrides?.detectAgentPlatforms)
+        return detectOverrides.detectAgentPlatforms();
     const home = process.env.HOME?.trim() || process.env.USERPROFILE?.trim();
     if (!home)
         return [];

package/dist/setup/legacy-config.js

@@ -0,0 +1,106 @@
+// 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 { getDefaultLlmConfig } from "../core/config/config.js";
+import { warn } from "../core/warn.js";
+import { v1ProfilePlatform } from "../integrations/harnesses/index.js";
+/** Read the currently-configured LLM connection from a loaded config. */
+export function getCurrentLlm(config) {
+    return getDefaultLlmConfig(config);
+}
+/** Read a synthesised legacy-shape agent block from the new-shape AkmConfig. */
+export function getCurrentAgentBlock(config) {
+    if (!config.profiles?.agent && !config.defaults?.agent)
+        return undefined;
+    const block = {};
+    if (config.defaults?.agent)
+        block.default = config.defaults.agent;
+    if (config.profiles?.agent) {
+        const profiles = {};
+        for (const [name, raw] of Object.entries(config.profiles.agent)) {
+            profiles[name] = {
+                ...(raw.platform === "opencode-sdk" ? { sdkMode: true } : {}),
+                ...(raw.model ? { model: raw.model } : {}),
+                ...(raw.bin ? { bin: raw.bin } : {}),
+                ...(raw.args ? { args: raw.args } : {}),
+            };
+        }
+        block.profiles = profiles;
+    }
+    return block;
+}
+/** Apply an LLM connection patch onto the new-shape config. */
+export function applyLegacyLlm(config, llm) {
+    if (!llm) {
+        // Clear the default LLM profile.
+        const name = config.defaults?.llm ?? "default";
+        const remaining = { ...(config.profiles?.llm ?? {}) };
+        delete remaining[name];
+        return {
+            profiles: { ...(config.profiles ?? {}), llm: remaining },
+            defaults: { ...(config.defaults ?? {}), llm: undefined },
+        };
+    }
+    const name = config.defaults?.llm ?? "default";
+    return {
+        profiles: {
+            ...(config.profiles ?? {}),
+            llm: { ...(config.profiles?.llm ?? {}), [name]: llm },
+        },
+        defaults: { ...(config.defaults ?? {}), llm: name },
+    };
+}
+/** Apply a legacy-shape agent block onto the new-shape config. */
+export function applyLegacyAgent(config, agent) {
+    if (!agent) {
+        return {
+            profiles: { ...(config.profiles ?? {}), agent: undefined },
+            defaults: { ...(config.defaults ?? {}), agent: undefined },
+        };
+    }
+    const v2Profiles = { ...(config.profiles?.agent ?? {}) };
+    for (const [name, profile] of Object.entries(agent.profiles ?? {})) {
+        // #566: resolve the platform via the harness registry instead of the old
+        // `name.includes("claude") ? "claude" : "opencode"` heuristic, which
+        // silently mapped Cursor/Copilot/any new harness to "opencode". An explicit
+        // sdkMode flag still wins; otherwise we ask the registry. A name the
+        // registry does not recognize is surfaced (warn) rather than silently
+        // misclassified, then kept as a best-effort "opencode" profile so the user
+        // does not lose a profile they explicitly configured.
+        let platform;
+        if (profile.sdkMode) {
+            platform = "opencode-sdk";
+        }
+        else {
+            const resolved = v1ProfilePlatform(name);
+            if (resolved) {
+                platform = resolved;
+            }
+            else {
+                warn(`[akm setup] Agent profile "${name}" did not match any known harness; ` +
+                    `defaulting its platform to "opencode". Set its platform explicitly in config if this is wrong.`);
+                platform = "opencode";
+            }
+        }
+        v2Profiles[name] = {
+            platform,
+            ...(profile.bin ? { bin: profile.bin } : {}),
+            ...(profile.args ? { args: profile.args } : {}),
+            ...(profile.model ? { model: profile.model } : {}),
+        };
+    }
+    return {
+        profiles: { ...(config.profiles ?? {}), agent: v2Profiles },
+        defaults: { ...(config.defaults ?? {}), agent: agent.default },
+    };
+}
+/** Deep-ish clone of an LLM connection config (capabilities + extraParams). */
+export function cloneLlmConfig(llm) {
+    if (!llm)
+        return undefined;
+    return {
+        ...llm,
+        ...(llm.capabilities ? { capabilities: { ...llm.capabilities } } : {}),
+        ...(llm.extraParams ? { extraParams: { ...llm.extraParams } } : {}),
+    };
+}

package/dist/setup/prompt.js

@@ -0,0 +1,57 @@
+// 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/.
+/**
+ * Clack prompt shims for the setup wizard: cancel-aware prompting so pressing
+ * Escape offers a confirm-to-quit rather than crashing the wizard.
+ */
+import * as p from "../cli/clack.js";
+export function bail() {
+    p.cancel("Setup cancelled. No changes were saved.");
+    process.exit(0);
+}
+/**
+ * Check if a prompt result was cancelled (Escape). If so, ask the user
+ * whether they really want to quit. Returns true if the user chose to
+ * stay (i.e. the caller should re-prompt), or calls bail() to exit.
+ *
+ * @internal Exported for testing only.
+ */
+export async function onCancel(value) {
+    if (!p.isCancel(value))
+        return false;
+    const confirmExit = await p.confirm({
+        message: "Exit the wizard? No changes will be saved.",
+        initialValue: false,
+    });
+    // Only exit when the user explicitly confirms "Yes".
+    // Pressing Escape on the confirmation (isCancel) or choosing "No"
+    // both mean "stay in the wizard".
+    if (confirmExit === true) {
+        bail();
+    }
+    // User chose to stay
+    return true;
+}
+/**
+ * Run a prompt function in a loop, retrying if the user presses Escape
+ * but decides to stay. Returns the non-cancelled result.
+ */
+export async function prompt(fn) {
+    for (;;) {
+        const result = await fn();
+        if (await onCancel(result))
+            continue;
+        return result;
+    }
+}
+/**
+ * Like `prompt`, but pressing Escape returns `null` instead of re-prompting.
+ * Use inside sub-actions so the user can back out to the parent menu.
+ */
+export async function promptOrBack(fn) {
+    const result = await fn();
+    if (p.isCancel(result))
+        return null;
+    return result;
+}

package/dist/setup/providers.js

@@ -0,0 +1,14 @@
+// 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/.
+/**
+ * Endpoint + default model for each cloud provider akm can recommend from a
+ * detected API key. A provider absent from this table yields no recommendation
+ * (the previous paired `switch`es both returned `undefined`).
+ */
+export const PROVIDER_DEFAULTS = {
+    anthropic: { endpoint: "https://api.anthropic.com/v1", model: "claude-sonnet-4-5" },
+    openai: { endpoint: "https://api.openai.com/v1", model: "gpt-4o-mini" },
+    gemini: { endpoint: "https://generativelanguage.googleapis.com/v1beta/openai", model: "gemini-1.5-flash" },
+    groq: { endpoint: "https://api.groq.com/openai/v1", model: "llama-3.3-70b-versatile" },
+};

package/dist/setup/registry-stash-loader.js

@@ -44,6 +44,13 @@ const FALLBACK_STASHES = [
         defaultSelected: false,
     },
 ];
+// ── Test seam ────────────────────────────────────────────────────────────────
+// Swap-and-restore override. Inert in production; only tests call the setter.
+let loadSetupStashesOverride;
+/** TEST-ONLY. Swap the implementation of `loadSetupStashes`; pass undefined to restore. */
+export function _setLoadSetupStashesForTests(fake) {
+    loadSetupStashesOverride = fake;
+}
 // ── Loader ──────────────────────────────────────────────────────────────────
 /**
  * Fetch available stashes from the registry and map to SetupStashEntry[].
@@ -55,6 +62,11 @@ const FALLBACK_STASHES = [
  * @param timeoutMs    Fetch timeout in ms (default: 4000).
  */
 export async function loadSetupStashes(registryUrl, timeoutMs = 4000) {
+    if (loadSetupStashesOverride)
+        return loadSetupStashesOverride(registryUrl, timeoutMs);
+    return loadSetupStashesReal(registryUrl, timeoutMs);
+}
+async function loadSetupStashesReal(registryUrl, timeoutMs = 4000) {
     try {
         const response = await fetch(registryUrl, {
             signal: AbortSignal.timeout(timeoutMs),

package/dist/setup/semantic-assets.js

@@ -0,0 +1,124 @@
+// 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/.
+/**
+ * Semantic-search asset preparation for the setup wizard. Isolates the one
+ * `bun add @huggingface/transformers` subprocess and the sqlite-vec probe so
+ * the rest of setup stays free of subprocess/DB I/O.
+ */
+import fs from "node:fs";
+import os from "node:os";
+import path from "node:path";
+import * as p from "../cli/clack.js";
+import { isHttpUrl } from "../core/common.js";
+import { closeDatabase, isVecAvailable, openIndexDatabase } from "../indexer/db/db.js";
+import { checkEmbeddingAvailability, DEFAULT_LOCAL_MODEL, isTransformersAvailable } from "../llm/embedder.js";
+import { getDirname, spawn } from "../runtime.js";
+// Approximate first-download sizes used in the setup note.
+// LOCAL_MODEL_APPROX_SIZE_MB tracks the default local model (DEFAULT_LOCAL_MODEL).
+const LOCAL_MODEL_APPROX_SIZE_MB = 130;
+// SQLITE_VEC_APPROX_SIZE_MB reflects the optional sqlite-vec install footprint.
+const SQLITE_VEC_APPROX_SIZE_MB = 5;
+export function isRemoteEmbeddingConfig(embedding) {
+    return isHttpUrl(embedding?.endpoint);
+}
+/**
+ * @internal Exported for testing only.
+ */
+export function describeSemanticSearchAssets(embedding) {
+    if (isRemoteEmbeddingConfig(embedding)) {
+        return [
+            `• Embedding endpoint: ${embedding?.provider ?? "custom"} / ${embedding?.model} (no local model download)`,
+            `• sqlite-vec acceleration: optional native extension (~${SQLITE_VEC_APPROX_SIZE_MB} MB when installed separately)`,
+        ];
+    }
+    return [
+        `• Local embedding model: ${embedding?.localModel ?? DEFAULT_LOCAL_MODEL} (~${LOCAL_MODEL_APPROX_SIZE_MB} MB download on first use)`,
+        `• sqlite-vec acceleration: optional native extension (~${SQLITE_VEC_APPROX_SIZE_MB} MB when installed separately)`,
+    ];
+}
+export async function prepareSemanticSearchAssets(config) {
+    const remote = isRemoteEmbeddingConfig(config.embedding);
+    // For local embeddings, ensure the required package is installed first.
+    if (!remote) {
+        if (!isTransformersAvailable()) {
+            const spin = p.spinner();
+            spin.start("Installing @huggingface/transformers...");
+            try {
+                const pkgRoot = path.resolve(getDirname(import.meta.url), "../..");
+                const proc = spawn(["bun", "add", "@huggingface/transformers"], {
+                    cwd: pkgRoot,
+                    stdout: "pipe",
+                    stderr: "pipe",
+                });
+                await proc.exited;
+                if (proc.exitCode !== 0) {
+                    const stderr = await new Response(proc.stderr).text();
+                    throw new Error(stderr || `exit code ${proc.exitCode}`);
+                }
+                spin.stop("@huggingface/transformers installed.");
+            }
+            catch (err) {
+                const msg = err instanceof Error ? err.message : String(err);
+                spin.stop("Could not install @huggingface/transformers.");
+                p.log.warn(`Automatic install failed: ${msg}\n` +
+                    "Install it manually with: bun add @huggingface/transformers\n" +
+                    "Then re-run `akm setup` or `akm index --full --verbose`.");
+                return { ok: false, reason: "missing-package", message: `Automatic install failed: ${msg}` };
+            }
+        }
+    }
+    const spin = p.spinner();
+    spin.start(remote
+        ? "Checking remote embedding endpoint..."
+        : `Downloading local embedding model (${config.embedding?.localModel ?? DEFAULT_LOCAL_MODEL})...`);
+    const result = await checkEmbeddingAvailability(config.embedding);
+    if (!result.available) {
+        spin.stop("Semantic-search assets could not be prepared.");
+        if (result.reason === "remote-unreachable") {
+            p.log.warn("The remote embedding endpoint is not reachable. Check your endpoint and credentials, then retry `akm index --full --verbose`.");
+            return { ok: false, reason: "remote-network", message: "The remote embedding endpoint is not reachable." };
+        }
+        else if (result.reason === "missing-package") {
+            p.log.warn("@huggingface/transformers is not installed. Install it with: bun add @huggingface/transformers\n" +
+                "Then re-run `akm setup` or `akm index --full --verbose`.");
+            return { ok: false, reason: "missing-package", message: "@huggingface/transformers is not installed." };
+        }
+        else {
+            p.log.warn(`The local embedding model could not be downloaded: ${result.message}\n` +
+                "Retry `akm index --full --verbose` after confirming local model downloads are permitted.");
+            return { ok: false, reason: "local-model-download", message: result.message };
+        }
+    }
+    spin.stop(remote ? "Remote embedding endpoint is ready." : "Local embedding model downloaded and ready.");
+    let db;
+    let probeDir;
+    try {
+        probeDir = fs.mkdtempSync(path.join(os.tmpdir(), "akm-setup-vec-probe-"));
+        db = openIndexDatabase(path.join(probeDir, "probe.db"), config.embedding?.dimension ? { embeddingDim: config.embedding.dimension } : undefined);
+        if (isVecAvailable(db)) {
+            p.log.info("sqlite-vec is available for fast vector search.");
+        }
+        else {
+            p.log.info("sqlite-vec is not available. Semantic search will use the JS fallback until the optional extension is installed.");
+        }
+    }
+    catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        p.log.warn(`Could not open the local database or check for sqlite-vec. Semantic search will use the JS fallback. (${message})\n` +
+            "Check file permissions and available disk space in the cache directory, or run `akm index --full --verbose` to diagnose.");
+    }
+    finally {
+        if (db)
+            closeDatabase(db);
+        if (probeDir) {
+            try {
+                fs.rmSync(probeDir, { recursive: true, force: true });
+            }
+            catch {
+                /* ignore cleanup failure */
+            }
+        }
+    }
+    return { ok: true };
+}