akm-cli 0.9.0-rc.1 → 0.9.0-rc.13

package/dist/scripts/migrations/v16-to-v17.js

@@ -1,141 +0,0 @@
-#!/usr/bin/env bun
-// @bun
-
-// scripts/migrations/v16-to-v17.ts
-import { Database } from "bun:sqlite";
-import fs from "fs";
-import path from "path";
-function parseArgs(argv) {
-  const args = {};
-  for (let i = 0;i < argv.length; i += 1) {
-    const token = argv[i];
-    if (token === "--backup") {
-      args.backup = argv[++i];
-    } else if (token === "--target") {
-      args.target = argv[++i];
-    } else if (token === "--help" || token === "-h") {
-      printHelpAndExit(0);
-    } else if (token?.startsWith("--")) {
-      console.error(`unknown flag: ${token}`);
-      printHelpAndExit(2);
-    }
-  }
-  if (!args.backup || !args.target) {
-    console.error("--backup and --target are both required");
-    printHelpAndExit(2);
-  }
-  return args;
-}
-function printHelpAndExit(code) {
-  console.error([
-    "Usage: bun scripts/migrations/v16-to-v17.ts --backup <path> --target <path>",
-    "",
-    "  --backup  Path to a backup directory (or backup index.db) written by",
-    "            AKM before the v16\u2192v17 upgrade.",
-    "  --target  Path to the current, live index.db. Rows are inserted in",
-    "            place; back this file up yourself if you want a safety net.",
-    "",
-    "Exit codes: 0 success, 2 usage error, 1 runtime failure."
-  ].join(`
-`));
-  process.exit(code);
-}
-function resolveDbPath(input, label) {
-  if (!fs.existsSync(input)) {
-    throw new Error(`${label} path does not exist: ${input}`);
-  }
-  const stat = fs.statSync(input);
-  if (stat.isFile())
-    return input;
-  if (stat.isDirectory()) {
-    const candidate = path.join(input, "index.db");
-    if (!fs.existsSync(candidate)) {
-      throw new Error(`${label} directory does not contain index.db: ${input}`);
-    }
-    return candidate;
-  }
-  throw new Error(`${label} path is neither a file nor a directory: ${input}`);
-}
-function reconcileUsageEvents(backup, target) {
-  const summary = { rowsInspected: 0, rowsInserted: 0, rowsSkipped: 0 };
-  const hasTable = backup.prepare("SELECT name FROM sqlite_master WHERE type='table' AND name='usage_events'").get();
-  if (!hasTable) {
-    console.error("[v16-to-v17] backup has no usage_events table; nothing to reconcile");
-    return summary;
-  }
-  const targetCols = target.prepare("PRAGMA table_info(usage_events)").all().map((c) => c.name);
-  const backupCols = backup.prepare("PRAGMA table_info(usage_events)").all().map((c) => c.name);
-  const sharedCols = backupCols.filter((c) => targetCols.includes(c) && c !== "id");
-  if (sharedCols.length === 0) {
-    console.error("[v16-to-v17] backup and target usage_events share no columns; refusing to insert");
-    return summary;
-  }
-  const selectAll = backup.prepare(`SELECT ${sharedCols.join(", ")} FROM usage_events`);
-  const probe = target.prepare(`SELECT 1 FROM usage_events
-       WHERE created_at = ?
-         AND event_type = ?
-         AND COALESCE(entry_ref, '') = COALESCE(?, '')
-         AND COALESCE(query, '')     = COALESCE(?, '')
-       LIMIT 1`);
-  const insert = target.prepare(`INSERT INTO usage_events (${sharedCols.join(", ")}) VALUES (${sharedCols.map(() => "?").join(", ")})`);
-  const insertTx = target.transaction((rows2) => {
-    for (const row of rows2) {
-      summary.rowsInspected += 1;
-      const created = row.created_at ?? null;
-      const type = row.event_type ?? null;
-      const ref = row.entry_ref ?? null;
-      const query = row.query ?? null;
-      if (!created || !type) {
-        summary.rowsSkipped += 1;
-        continue;
-      }
-      const exists = probe.get(created, type, ref, query);
-      if (exists) {
-        summary.rowsSkipped += 1;
-        continue;
-      }
-      insert.run(...sharedCols.map((c) => row[c] ?? null));
-      summary.rowsInserted += 1;
-    }
-  });
-  const rows = selectAll.all();
-  insertTx(rows);
-  return summary;
-}
-function main() {
-  const argv = process.argv.slice(2);
-  const args = parseArgs(argv);
-  const backupPath = resolveDbPath(args.backup, "--backup");
-  const targetPath = resolveDbPath(args.target, "--target");
-  if (path.resolve(backupPath) === path.resolve(targetPath)) {
-    console.error("--backup and --target resolve to the same file; refusing to operate on a single DB");
-    process.exit(2);
-  }
-  const start = Date.now();
-  const backup = new Database(backupPath, { readonly: true });
-  const target = new Database(targetPath);
-  try {
-    target.exec("PRAGMA foreign_keys = ON");
-    target.exec("PRAGMA busy_timeout = 5000");
-    const usageSummary = reconcileUsageEvents(backup, target);
-    const out = {
-      from: "v16",
-      to: "v17",
-      tablesReconciled: ["usage_events"],
-      rowsInspected: usageSummary.rowsInspected,
-      rowsInserted: usageSummary.rowsInserted,
-      rowsSkipped: usageSummary.rowsSkipped,
-      durationMs: Date.now() - start
-    };
-    console.log(JSON.stringify(out, null, 2));
-  } finally {
-    backup.close();
-    target.close();
-  }
-}
-try {
-  main();
-} catch (err) {
-  console.error(err instanceof Error ? err.message : String(err));
-  process.exit(1);
-}

package/dist/setup/legacy-config.js

@@ -1,106 +0,0 @@
-// 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/storage/repositories/consolidation-repository.js

@@ -1,38 +0,0 @@
-// 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/.
-/**
- * Bulk-fetch the judged-state cache for a set of entry keys in one query.
- * Returns a Map keyed by entry_key so the consolidate pool-selection loop can
- * do O(1) "has this memory been judged at this content hash?" lookups.
- * Empty input → empty map (no query issued).
- */
-export function getConsolidationJudgedMap(db, entryKeys) {
-    const out = new Map();
-    if (entryKeys.length === 0)
-        return out;
-    // SQLite has a ~999 param ceiling; chunk if a caller ever exceeds that.
-    const CHUNK = 500;
-    for (let i = 0; i < entryKeys.length; i += CHUNK) {
-        const chunk = entryKeys.slice(i, i + CHUNK);
-        const placeholders = chunk.map(() => "?").join(",");
-        const rows = db
-            .prepare(`SELECT * FROM consolidation_judged WHERE entry_key IN (${placeholders})`)
-            .all(...chunk);
-        for (const row of rows)
-            out.set(row.entry_key, row);
-    }
-    return out;
-}
-/**
- * Record (or update) the judged state for one memory. INSERT-OR-REPLACE so the
- * row always reflects the most recent judge of that entry_key. Called once per
- * memory the consolidate LLM saw in a successfully-judged chunk.
- */
-export function upsertConsolidationJudged(db, input) {
-    db.prepare(`
-    INSERT OR REPLACE INTO consolidation_judged
-      (entry_key, content_hash, judged_at, outcome)
-    VALUES (?, ?, ?, ?)
-  `).run(input.entryKey, input.contentHash, input.judgedAt, input.outcome);
-}

package/dist/storage/repositories/recombine-repository.js

@@ -1,213 +0,0 @@
-// 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/.
-/**
- * Record an induction of a recombine hypothesis and return the new consecutive
- * count. INSERT … ON CONFLICT increments the streak, but the `last_run` guard
- * makes a repeated call within the SAME run idempotent (no double-increment if
- * the same ref appears twice in one run). On insert the streak starts at 1.
- */
-export function recordRecombineInduction(db, input) {
-    const row = db
-        .prepare(`
-      INSERT INTO recombine_hypotheses
-        (hypothesis_ref, signature, member_key, consecutive_count, first_seen_at, last_seen_at, last_run)
-      VALUES (?, ?, ?, 1, ?, ?, ?)
-      ON CONFLICT(hypothesis_ref) DO UPDATE SET
-        consecutive_count = consecutive_count + (CASE WHEN last_run IS excluded.last_run THEN 0 ELSE 1 END),
-        last_seen_at = excluded.last_seen_at,
-        last_run = excluded.last_run,
-        signature = excluded.signature,
-        member_key = excluded.member_key
-      RETURNING consecutive_count
-    `)
-        .get(input.hypothesisRef, input.signature, input.memberKey, input.seenAt, input.seenAt, input.run);
-    return row?.consecutive_count ?? 0;
-}
-/**
- * #633 — find an existing pending (non-promoted) hypothesis row whose cluster
- * is the SAME generalization as a newly-induced one, matched by SIGNATURE plus
- * a Jaccard membership-overlap test, rather than an exact member-set hash.
- *
- * In a growing stash any added/removed memory changes the exact member set, so
- * the ref hash (and member_key) shift every run → a fresh row at count=1 → the
- * streak never reaches `confirmThreshold` and nothing ever promotes. Matching
- * on overlap lets a drifting-but-stable cluster keep accumulating under one row.
- *
- * Returns the matched row with the HIGHEST overlap (ties broken by most-recent
- * `last_seen_at`), or `undefined` when none clears `minOverlap`. Already-promoted
- * rows are ignored so a confirmed lesson is not reopened by a later induction.
- *
- * @param memberKey  the candidate cluster's membership fingerprint
- *                   (sorted member entryKeys joined by `|`).
- * @param minOverlap Jaccard threshold in [0,1]; a candidate matches when
- *                   |A∩B| / |A∪B| >= minOverlap.
- */
-export function findMatchingRecombineHypothesis(db, input) {
-    const candidateMembers = new Set(input.memberKey.split("|").filter((m) => m.length > 0));
-    if (candidateMembers.size === 0)
-        return undefined;
-    const rows = db
-        .prepare("SELECT * FROM recombine_hypotheses WHERE signature = ? AND promoted_at IS NULL ORDER BY last_seen_at DESC")
-        .all(input.signature);
-    let best;
-    let bestOverlap = -1;
-    for (const row of rows) {
-        const rowMembers = row.member_key.split("|").filter((m) => m.length > 0);
-        if (rowMembers.length === 0)
-            continue;
-        let intersection = 0;
-        for (const m of rowMembers) {
-            if (candidateMembers.has(m))
-                intersection += 1;
-        }
-        const union = candidateMembers.size + rowMembers.length - intersection;
-        const overlap = union === 0 ? 0 : intersection / union;
-        // rows are ordered last_seen_at DESC, so a strict `>` keeps the most-recent
-        // row on ties.
-        if (overlap >= input.minOverlap && overlap > bestOverlap) {
-            best = row;
-            bestOverlap = overlap;
-        }
-    }
-    return best;
-}
-/**
- * Fetch a single recombine hypothesis row, or `undefined` when the ref has
- * never been induced. Normalizes bun:sqlite null → undefined like
- * {@link getExtractedSession}.
- */
-export function getRecombineHypothesis(db, hypothesisRef) {
-    const row = db
-        .prepare("SELECT * FROM recombine_hypotheses WHERE hypothesis_ref = ?")
-        .get(hypothesisRef);
-    return row ?? undefined;
-}
-/**
- * Mark a hypothesis promoted: stamp `promoted_at` and reset the consecutive
- * count to 0, so it must re-accumulate a full confirmation streak before it can
- * promote again. The `promoted_at` non-null state is the double-promotion guard.
- */
-export function markRecombineHypothesisPromoted(db, hypothesisRef, promotedAt) {
-    db.prepare("UPDATE recombine_hypotheses SET promoted_at = ?, consecutive_count = 0 WHERE hypothesis_ref = ?").run(promotedAt, hypothesisRef);
-}
-/**
- * #658 — does any current-run cluster match this hypothesis row under the SAME
- * signature + Jaccard-overlap rule used for re-induction? A match means the
- * cluster genuinely re-formed this run (it was merely cap-displaced out of the
- * processed top-`maxClustersPerRun` slice), so its streak must NOT be reset.
- */
-function hypothesisMatchesAnyPresentCluster(row, presentClusters, minOverlap) {
-    const rowMembers = row.member_key.split("|").filter((m) => m.length > 0);
-    if (rowMembers.length === 0)
-        return false;
-    const rowSet = new Set(rowMembers);
-    for (const cluster of presentClusters) {
-        if (cluster.signature !== row.signature)
-            continue;
-        const clusterMembers = cluster.memberKey.split("|").filter((m) => m.length > 0);
-        if (clusterMembers.length === 0)
-            continue;
-        let intersection = 0;
-        for (const m of clusterMembers) {
-            if (rowSet.has(m))
-                intersection += 1;
-        }
-        const union = rowSet.size + clusterMembers.length - intersection;
-        const overlap = union === 0 ? 0 : intersection / union;
-        if (overlap >= minOverlap)
-            return true;
-    }
-    return false;
-}
-/**
- * Decay-to-zero every NON-promoted hypothesis NOT re-induced in the current run.
- *
- * A generalization that stops being supported by the corpus has lost its
- * confirmation streak, so we hard-reset `consecutive_count` to 0 (the
- * alternative — `count - 1` floored at 0 — tolerates a single noisy run but
- * blurs the "consecutive" semantics; hard-reset is the conservative choice).
- *
- * Only rows whose `hypothesis_ref` is NOT in `seenRefs` AND whose `last_run` is
- * NOT the current run are decayed. Already-promoted rows are left alone.
- *
- * #658 — CAP-AWARE decay. The recombine pass only re-inducts (and thus marks
- * `seen`) the top-`maxClustersPerRun` clusters, but a cluster genuinely
- * re-forms every run even when it is displaced below that cap. Resetting such a
- * row treats a SCHEDULING miss as a SUBSTANCE miss and traps the hypothesis
- * below `confirmThreshold` forever. When `opts.presentClusters` is supplied, a
- * row is SPARED from decay if it Jaccard-matches any present cluster (same
- * signature, overlap >= `opts.minOverlap`) — i.e. its cluster re-formed this run
- * but was cap-displaced. This does NOT advance the streak (only re-induction in
- * the processed slice does that, via {@link recordRecombineInduction}), so the
- * recurrence bar for promotion is unchanged; it only stops the cap from
- * manufacturing artificial misses. Omitting `presentClusters` preserves the
- * pre-#658 hard-reset-after-one-miss behaviour exactly.
- *
- * Returns the number of rows reset.
- */
-export function decayUnseenRecombineHypotheses(db, currentRun, seenRefs, opts) {
-    // #658 — when cap-aware sparing is requested, fold the cap-displaced rows into
-    // the "seen" exclusion set: the underlying reset SQL already protects every
-    // ref it is given, so sparing == treating a spared row exactly like a seen
-    // row for this sweep (its count is left untouched, never advanced).
-    let effectiveSeen = seenRefs;
-    if (opts && opts.presentClusters.length > 0) {
-        const candidates = db
-            .prepare("SELECT hypothesis_ref, signature, member_key FROM recombine_hypotheses WHERE promoted_at IS NULL AND (last_run IS NULL OR last_run != ?) AND consecutive_count != 0")
-            .all(currentRun);
-        const seenSet = new Set(seenRefs);
-        for (const row of candidates) {
-            if (seenSet.has(row.hypothesis_ref))
-                continue;
-            if (hypothesisMatchesAnyPresentCluster(row, opts.presentClusters, opts.minOverlap)) {
-                seenSet.add(row.hypothesis_ref);
-            }
-        }
-        effectiveSeen = [...seenSet];
-    }
-    return decayUnseenRecombineHypothesesInner(db, currentRun, effectiveSeen);
-}
-/**
- * The raw reset sweep shared by the cap-aware wrapper above. Resets every
- * non-promoted row from a prior run whose ref is NOT in `seenRefs`. Kept private
- * so the param-ceiling chunking logic lives in one place.
- */
-function decayUnseenRecombineHypothesesInner(db, currentRun, seenRefs) {
-    // Reset every eligible row, then exclude the seen refs in chunks to respect
-    // the ~999 SQLite param ceiling. With no seen refs we reset all non-promoted
-    // rows from prior runs in a single statement.
-    if (seenRefs.length === 0) {
-        const res = db
-            .prepare("UPDATE recombine_hypotheses SET consecutive_count = 0 WHERE promoted_at IS NULL AND (last_run IS NULL OR last_run != ?) AND consecutive_count != 0")
-            .run(currentRun);
-        return Number(res.changes);
-    }
-    // A single NOT IN keeps the exclusion atomic (a chunked NOT IN would let a ref
-    // excluded by one chunk still be reset by another chunk's statement). The
-    // recombine pass caps RE-INDUCED clusters at `maxClustersPerRun` (a handful) —
-    // but with #658 cap-aware sparing the caller folds every cap-displaced
-    // (present-but-unprocessed) hypothesis into `effectiveSeen` too, so on a large
-    // stash `seenRefs` here can carry MANY spared refs, not just the handful that
-    // were processed. We cap defensively at ~900 (under SQLite's ~999 param
-    // ceiling): if `effectiveSeen` somehow exceeds it we fall back to resetting all
-    // eligible rows — which re-introduces the cap-displacement trap for THAT run
-    // (spared rows get decayed because the NOT IN protection is dropped). That is a
-    // rare, bounded degradation; a stash with >900 simultaneously-spared
-    // hypotheses is far beyond current scale.
-    if (seenRefs.length > 900) {
-        const res = db
-            .prepare("UPDATE recombine_hypotheses SET consecutive_count = 0 WHERE promoted_at IS NULL AND (last_run IS NULL OR last_run != ?) AND consecutive_count != 0")
-            .run(currentRun);
-        return Number(res.changes);
-    }
-    const placeholders = seenRefs.map(() => "?").join(",");
-    const res = db
-        .prepare(`UPDATE recombine_hypotheses SET consecutive_count = 0
-       WHERE promoted_at IS NULL
-         AND (last_run IS NULL OR last_run != ?)
-         AND consecutive_count != 0
-         AND hypothesis_ref NOT IN (${placeholders})`)
-        .run(currentRun, ...seenRefs);
-    return Number(res.changes);
-}

package/dist/wiki/wiki-templates.js

@@ -1,15 +0,0 @@
-// 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 indexTemplate from "../assets/wiki/index-template.md" with { type: "text" };
-import logTemplate from "../assets/wiki/log-template.md" with { type: "text" };
-import schemaTemplate from "../assets/wiki/schema-template.md" with { type: "text" };
-export function buildSchemaMd(wikiName) {
-    return schemaTemplate.replaceAll("{{WIKI_NAME}}", wikiName);
-}
-export function buildIndexMd(wikiName) {
-    return indexTemplate.replaceAll("{{WIKI_NAME}}", wikiName);
-}
-export function buildLogMd(wikiName) {
-    return logTemplate.replaceAll("{{WIKI_NAME}}", wikiName);
-}