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

package/dist/storage/locations.js

@@ -1,7 +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 { getCacheDir, getConfigDir, getDataDir, getDbPath, getDefaultStashDir, getLockfileLockPath, getLockfilePath, getWorkflowDbPath, } from "../core/paths.js";
+import { getCacheDir, getConfigDir, getDataDir, getDbPath, getDefaultStashDir, getLockfileLockPath, getLockfilePath, } from "../core/paths.js";
 import { getStateDbPath } from "../core/state-db.js";
 /**
  * Resolve the current {@link StorageLocations} by delegating to the existing
@@ -14,7 +14,6 @@ export function resolveStorageLocations() {
     return {
         indexDb: getDbPath(),
         stateDb: getStateDbPath(),
-        workflowDb: getWorkflowDbPath(),
         lockfile: getLockfilePath(),
         lockfileSentinel: getLockfileLockPath(),
         dataDir: getDataDir(),

package/dist/storage/repositories/improve-runs-repository.js

@@ -2,26 +2,6 @@
 // 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 { classifyImproveAction } from "../../core/improve-types.js";
-// ── Per-phase gate threshold store (Migration 012) ───────────────────────────
-/**
- * Read the persisted auto-tuned threshold for a gate phase.
- *
- * Returns `undefined` when no row exists yet (first run, or the phase has
- * never been tuned). The caller falls back to the global `options.autoAccept`
- * in that case.
- */
-export function getPhaseThreshold(db, phase) {
-    const row = db.prepare("SELECT threshold FROM improve_gate_thresholds WHERE phase = ?").get(phase);
-    return row?.threshold;
-}
-/**
- * Persist the auto-tuned threshold for a gate phase.
- * Uses INSERT OR REPLACE so the call is idempotent (upsert semantics).
- */
-export function persistPhaseThreshold(db, phase, threshold) {
-    db.prepare(`INSERT OR REPLACE INTO improve_gate_thresholds (phase, threshold, updated_at)
-     VALUES (?, ?, ?)`).run(phase, Math.round(threshold), Date.now());
-}
 /**
  * Compute the cheap aggregate metrics blob from a full improve result.
  *

package/dist/storage/repositories/index-connection.js

@@ -0,0 +1,80 @@
+// 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/.
+/**
+ * `index.db` connection lifecycle for the storage layer.
+ *
+ * Opens/closes the index database, arming the sqlite-vec extension and (for the
+ * managed open path) running `ensureSchema`. Extracted verbatim from
+ * `src/indexer/db/db.ts` (WI-5a); it now lives BELOW the indexer, so the storage
+ * loan helpers (`index-db.ts`, `registry-cache.ts`) import their opener from a
+ * sibling here instead of reaching up into the indexer — inverting the old
+ * storage→indexer arrow.
+ */
+import fs from "node:fs";
+import { createRequire } from "node:module";
+import { getDbPath } from "../../core/paths.js";
+import { openDatabase } from "../database.js";
+import { openManagedDatabase } from "../managed-db.js";
+import { ensureSchema } from "./index-schema.js";
+import { loadVecExtension, warnIfVecMissing } from "./index-vec-repository.js";
+export function openIndexDatabase(dbPath, options) {
+    return openManagedDatabase({
+        path: dbPath ?? getDbPath(),
+        init: (db) => {
+            // Try to load sqlite-vec extension
+            loadVecExtension(db);
+            // Dim resolution: explicit option wins; otherwise consult the on-disk
+            // config so unparameterised opens (registry providers, graph helpers,
+            // ad-hoc CLI subcommands) honour the operator-declared dimension. Only if
+            // both are absent do we fall through to the no-clobber path, which keeps
+            // ensureSchema from touching `index_meta.embeddingDim` at all.
+            const resolvedDim = options?.embeddingDim ?? resolveConfiguredEmbeddingDim();
+            ensureSchema(db, resolvedDim);
+            // Warn once at init if using JS fallback with many entries
+            warnIfVecMissing(db, { once: true });
+        },
+    });
+}
+/**
+ * Read the operator-configured embedding dimension from the on-disk config.
+ * Returns `undefined` when no config file is present, when the config has
+ * no `embedding.dimension` set, or when reading the config throws (e.g.
+ * inside isolated test fixtures with no XDG home). Failure is silent on
+ * purpose — every openDatabase() call would otherwise have to handle a
+ * config-not-found error path, and the fallback (no-clobber semantics) is
+ * already correct.
+ */
+function resolveConfiguredEmbeddingDim() {
+    try {
+        const esmRequire = createRequire(import.meta.url);
+        const { loadConfig } = esmRequire("../../core/config/config");
+        const dim = loadConfig().embedding?.dimension;
+        if (typeof dim === "number" && Number.isInteger(dim) && dim > 0 && dim <= 4096) {
+            return dim;
+        }
+        return undefined;
+    }
+    catch {
+        return undefined;
+    }
+}
+export function openExistingDatabase(dbPath) {
+    // Existing-DB callers must not mutate schema or embedding metadata on open,
+    // but some paths still need write access to usage_events and other tables —
+    // so init only loads the vec extension, it does not run ensureSchema.
+    return openManagedDatabase({ path: dbPath ?? getDbPath(), init: loadVecExtension });
+}
+/**
+ * Open an existing index for queries without creating directories, a database
+ * file, journals, or running write-capable pragmas/schema initialization.
+ */
+export function openReadonlyExistingDatabase(dbPath) {
+    const resolvedPath = dbPath ?? getDbPath();
+    if (!fs.existsSync(resolvedPath))
+        return undefined;
+    return openDatabase(resolvedPath, { readonly: true, create: false });
+}
+export function closeDatabase(db) {
+    db.close();
+}

package/dist/storage/repositories/index-db.js

@@ -1,9 +1,9 @@
 // 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 { openExistingDatabase } from "../../indexer/db/db.js";
 import { resolveStorageLocations } from "../locations.js";
 import { withManagedDb } from "../managed-db.js";
+import { openExistingDatabase } from "./index-connection.js";
 /**
  * Busy-timeout (ms) for read-path telemetry writers. Small on purpose: a
  * usage-event insert contending with a background reindex should be dropped,
@@ -13,8 +13,9 @@ export const TELEMETRY_BUSY_TIMEOUT_MS = 250;
 /**
  * Scoped-resource (loan pattern) helper for the index database (`index.db`).
  *
- * This is the `index.db` twin of {@link ../../workflows/db withWorkflowDb} /
- * {@link ./workflow-runs-repository withWorkflowRunsRepo}: it opens the index
+ * This is the `index.db` twin of the state.db loan helpers ({@link
+ * ../../core/state-db withStateDb} / {@link ./workflow-runs-repository
+ * withWorkflowRunsRepo}): it opens the index
  * database bound to {@link StorageLocations.indexDb}, runs `fn` against the live
  * {@link Database}, and closes the connection exactly once when `fn` returns —
  * even if `fn` throws. Callers no longer hand-roll `open / try / finally / close`