akm-cli 0.7.5 → 0.8.0-rc.6

package/dist/commands/history.js

@@ -1,53 +1,15 @@
-/**
- * `akm history` — surfaces internal mutation/usage events for a single asset
- * (`--ref`) or stash-wide.
- *
- * Event sources:
- *   - `usage_events` SQLite table: search, show, and feedback events recorded
- *     by the local indexer during normal CLI use.
- *   - `events.jsonl` append-only stream (opt-in via `--include-proposals`):
- *     proposal lifecycle events (`promoted`, `rejected`) emitted by
- *     `akm proposal accept` / `akm proposal reject`. Use this flag to see
- *     the full proposal review trail alongside usage events.
- *
- * The two sources are merged and sorted chronologically (oldest first) so
- * consumers see a coherent lifecycle trail in a single output.
- */
+// 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 { parseAssetRef } from "../core/asset-ref";
 import { UsageError } from "../core/errors";
 import { readEvents } from "../core/events";
+import { listProposals } from "../core/proposals";
+import { isoToSqlite, parseSinceToIso } from "../core/time";
 import { closeDatabase, openExistingDatabase } from "../indexer/db";
 // Proposal lifecycle event types emitted by the proposal substrate (#225).
 const PROPOSAL_EVENT_TYPES = new Set(["promoted", "rejected"]);
 // ── Helpers ──────────────────────────────────────────────────────────────────
-function normalizeSince(since) {
-    // Accept "YYYY-MM-DD", "YYYY-MM-DDTHH:MM:SSZ", epoch ms, or anything Date can parse.
-    const trimmed = since.trim();
-    if (!trimmed) {
-        throw new UsageError("--since cannot be empty.", "INVALID_FLAG_VALUE");
-    }
-    // Pure-digit input → epoch milliseconds
-    if (/^\d+$/.test(trimmed)) {
-        const ms = Number.parseInt(trimmed, 10);
-        const d = new Date(ms);
-        if (Number.isNaN(d.getTime())) {
-            throw new UsageError(`Invalid --since value: ${since}`, "INVALID_FLAG_VALUE");
-        }
-        return d
-            .toISOString()
-            .replace("T", " ")
-            .replace(/\.\d+Z$/, "");
-    }
-    const parsed = new Date(trimmed);
-    if (Number.isNaN(parsed.getTime())) {
-        throw new UsageError(`Invalid --since value: ${since}. Expected ISO timestamp (e.g. 2026-04-01T00:00:00Z) or epoch ms.`, "INVALID_FLAG_VALUE");
-    }
-    // Match the "YYYY-MM-DD HH:MM:SS" format SQLite's datetime('now') stores.
-    return parsed
-        .toISOString()
-        .replace("T", " ")
-        .replace(/\.\d+Z$/, "");
-}
 function parseMetadata(raw) {
     if (!raw)
         return null;
@@ -66,6 +28,7 @@ function toEntry(row) {
         entryId: row.entry_id,
         query: row.query,
         signal: row.signal,
+        source: row.source,
         metadata: parseMetadata(row.metadata),
         createdAt: row.created_at,
     };
@@ -104,7 +67,7 @@ export async function akmHistory(options = {}) {
         parseAssetRef(trimmed);
         normalizedRef = trimmed;
     }
-    const sinceNormalized = options.since !== undefined ? normalizeSince(options.since) : undefined;
+    const sinceNormalized = options.since !== undefined ? isoToSqlite(parseSinceToIso(options.since)) : undefined;
     const db = options.db ?? openExistingDatabase();
     const ownsDb = options.db === undefined;
     try {
@@ -118,8 +81,12 @@ export async function akmHistory(options = {}) {
             conditions.push("created_at >= ?");
             params.push(sinceNormalized);
         }
+        if (options.source !== undefined) {
+            conditions.push("source = ?");
+            params.push(options.source);
+        }
         const where = conditions.length > 0 ? `WHERE ${conditions.join(" AND ")}` : "";
-        const sql = `SELECT id, event_type, query, entry_id, entry_ref, signal, metadata, created_at
+        const sql = `SELECT id, event_type, query, entry_id, entry_ref, signal, metadata, source, created_at
                  FROM usage_events ${where}
                  ORDER BY id ASC`;
         const rows = db.prepare(sql).all(...params);
@@ -128,7 +95,7 @@ export async function akmHistory(options = {}) {
         const sources = ["usage_events"];
         const proposalEntries = [];
         if (options.includeProposals === true) {
-            sources.push("events.jsonl");
+            sources.push("state.db");
             // Convert sinceNormalized ("YYYY-MM-DD HH:MM:SS") to ISO for readEvents
             // which uses `ts >= since` where `ts` is ISO-8601.
             const sinceIso = sinceNormalized !== undefined ? `${sinceNormalized.replace(" ", "T")}Z` : undefined;
@@ -154,6 +121,7 @@ export async function akmHistory(options = {}) {
                     entryId: null,
                     query: null,
                     signal: null,
+                    source: null,
                     metadata: event.metadata ?? null,
                     createdAt,
                 });
@@ -169,6 +137,45 @@ export async function akmHistory(options = {}) {
                 return 1;
             return a.id - b.id;
         });
+        // ── Accept-rate-per-source (F-4 / #385) ─────────────────────────────────
+        let acceptRateBySource;
+        if (options.acceptRateBySource) {
+            const stashDir = options.stashDir;
+            if (stashDir) {
+                const bySource = new Map();
+                const countProposals = (statuses, includeArchive) => {
+                    for (const status of statuses) {
+                        const proposals = listProposals(stashDir, { status, includeArchive });
+                        for (const p of proposals) {
+                            const src = p.source || "(unknown)";
+                            const entry = bySource.get(src) ?? { accepted: 0, rejected: 0, pending: 0 };
+                            if (status === "accepted")
+                                entry.accepted++;
+                            else if (status === "rejected")
+                                entry.rejected++;
+                            else
+                                entry.pending++;
+                            bySource.set(src, entry);
+                        }
+                    }
+                };
+                countProposals(["pending"], false);
+                countProposals(["accepted", "rejected"], true);
+                acceptRateBySource = Array.from(bySource.entries())
+                    .map(([source, counts]) => {
+                    const decided = counts.accepted + counts.rejected;
+                    return {
+                        source,
+                        total: decided + counts.pending,
+                        accepted: counts.accepted,
+                        rejected: counts.rejected,
+                        pending: counts.pending,
+                        acceptRate: decided > 0 ? counts.accepted / decided : null,
+                    };
+                })
+                    .sort((a, b) => b.total - a.total); // Most active source first
+            }
+        }
         const response = {
             schemaVersion: 1,
             ...(normalizedRef !== undefined ? { ref: normalizedRef } : {}),
@@ -176,6 +183,7 @@ export async function akmHistory(options = {}) {
             totalCount: entries.length,
             entries,
             sources,
+            ...(acceptRateBySource !== undefined ? { acceptRateBySource } : {}),
         };
         return response;
     }

package/dist/commands/improve-profiles.js

@@ -0,0 +1,146 @@
+// 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 { parseAssetRef } from "../core/asset-ref";
+import { warn } from "../core/warn";
+/** Profile name used as the final fallback when nothing else resolves. */
+const FALLBACK_PROFILE_NAME = "default";
+// Built-in default allowed types per process
+export const DEFAULT_ALLOWED_TYPES = {
+    reflect: ["agent", "command", "knowledge", "lesson", "memory", "skill", "wiki", "workflow"],
+    distill: ["memory"],
+    consolidate: ["memory"],
+};
+const BUILTIN_PROFILES = {
+    default: {
+        description: "Standard improve pass — all sub-processes, markdown asset types.",
+        processes: {
+            reflect: { enabled: true, allowedTypes: DEFAULT_ALLOWED_TYPES.reflect },
+            distill: { enabled: true, allowedTypes: DEFAULT_ALLOWED_TYPES.distill },
+            consolidate: { enabled: true, allowedTypes: DEFAULT_ALLOWED_TYPES.consolidate },
+            memoryInference: { enabled: true },
+            graphExtraction: { enabled: true },
+            feedbackDistillation: { enabled: true },
+            // validation: deliberately undefined — third-tier classifier is opt-in.
+        },
+    },
+    quick: {
+        description: "Reflect-only pass — no distill, consolidate, memoryInference, or graphExtraction.",
+        processes: {
+            reflect: { enabled: true, allowedTypes: DEFAULT_ALLOWED_TYPES.reflect },
+            distill: { enabled: false },
+            consolidate: { enabled: false },
+            memoryInference: { enabled: false },
+            graphExtraction: { enabled: false },
+            feedbackDistillation: { enabled: false },
+        },
+    },
+    thorough: {
+        // Reserved for future divergence; for now behaviorally identical to
+        // `default`. Documented here so callers picking `--profile thorough` do
+        // not expect a different code path until we wire stricter limits in.
+        description: "All sub-processes enabled (currently identical to default; reserved for future divergence).",
+        processes: {
+            reflect: { enabled: true, allowedTypes: DEFAULT_ALLOWED_TYPES.reflect },
+            distill: { enabled: true, allowedTypes: DEFAULT_ALLOWED_TYPES.distill },
+            consolidate: { enabled: true, allowedTypes: DEFAULT_ALLOWED_TYPES.consolidate },
+            memoryInference: { enabled: true },
+            graphExtraction: { enabled: true },
+            feedbackDistillation: { enabled: true },
+        },
+    },
+    "memory-focus": {
+        description: "Memory and lesson improvement only — no distill or consolidate.",
+        processes: {
+            reflect: { enabled: true, allowedTypes: ["memory", "lesson"] },
+            distill: { enabled: false },
+            consolidate: { enabled: false },
+            memoryInference: { enabled: true },
+            graphExtraction: { enabled: false },
+            feedbackDistillation: { enabled: false },
+        },
+    },
+};
+/**
+ * Default enabled-state for known improve processes when neither the user
+ * profile nor the built-in default profile specifies an override.
+ *
+ * These mirror the legacy `LlmFeatureFlags` defaults so callers that bypass
+ * the profile system (rare — most run through `resolveImproveProfile`) get
+ * the same answer.
+ */
+const IMPROVE_PROCESS_DEFAULTS = {
+    reflect: true,
+    distill: true,
+    consolidate: true,
+    memoryInference: true,
+    graphExtraction: true,
+    feedbackDistillation: true,
+    validation: false,
+};
+/**
+ * Compute the effective enabled-state for a named improve process.
+ *
+ * Resolution order: explicit `profile.processes.<name>.enabled` (boolean) →
+ * the built-in {@link IMPROVE_PROCESS_DEFAULTS} fallback → `false`.
+ */
+export function resolveProcessEnabled(processName, profile) {
+    const processes = profile.processes;
+    const entry = processes?.[processName];
+    if (entry && typeof entry.enabled === "boolean")
+        return entry.enabled;
+    return IMPROVE_PROCESS_DEFAULTS[processName] ?? false;
+}
+function deepMerge(base, override) {
+    if (typeof base !== "object" || base === null)
+        return override ?? base;
+    const result = { ...base };
+    for (const key of Object.keys(override)) {
+        const ov = override[key];
+        // Treat `null` the same as `undefined` so user overrides never wipe a
+        // built-in field with `null`. The on-disk parser already strips nulls,
+        // but the programmatic API exposes this path and callers occasionally
+        // pass JSON-shaped objects with explicit nulls.
+        if (ov !== undefined && ov !== null) {
+            const bv = base[key];
+            if (typeof bv === "object" && bv !== null && typeof ov === "object" && ov !== null && !Array.isArray(bv)) {
+                result[key] = deepMerge(bv, ov);
+            }
+            else {
+                result[key] = ov;
+            }
+        }
+    }
+    return result;
+}
+export function resolveImproveProfile(name, config) {
+    const requestedName = name ??
+        (typeof config.defaults?.improve === "string" ? config.defaults.improve : undefined) ??
+        FALLBACK_PROFILE_NAME;
+    const hasBuiltin = requestedName in BUILTIN_PROFILES;
+    const hasUserDefined = !!config.profiles?.improve?.[requestedName];
+    let effectiveName = requestedName;
+    if (!hasBuiltin && !hasUserDefined && requestedName !== FALLBACK_PROFILE_NAME) {
+        warn(`[akm] Improve profile "${requestedName}" not found in built-ins or config. ` +
+            `Falling back to "${FALLBACK_PROFILE_NAME}".`);
+        effectiveName = FALLBACK_PROFILE_NAME;
+    }
+    const builtin = BUILTIN_PROFILES[effectiveName] ?? BUILTIN_PROFILES[FALLBACK_PROFILE_NAME];
+    const userOverride = config.profiles?.improve?.[effectiveName] ?? {};
+    return deepMerge(builtin, userOverride);
+}
+export function shouldSkipRef(ref, processName, profile) {
+    const cfg = profile.processes?.[processName];
+    // Check if the process itself is disabled
+    if (cfg?.enabled === false)
+        return { skip: true, reason: "process-disabled" };
+    const parsed = parseAssetRef(ref);
+    const allowed = cfg?.allowedTypes ?? DEFAULT_ALLOWED_TYPES[processName];
+    if (!allowed.includes(parsed.type))
+        return { skip: true, reason: "type-filter" };
+    // Hardcoded: wiki raw directories are never processed by any improve process.
+    if (parsed.type === "wiki" && parsed.name.split("/")[1] === "raw") {
+        return { skip: true, reason: "raw-wiki" };
+    }
+    return { skip: false, reason: "" };
+}

package/dist/commands/improve-result-file.js

@@ -0,0 +1,103 @@
+// 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/.
+/**
+ * Helpers for persisting the `akm improve` result envelope.
+ *
+ * v0.8.0 behavioural default change:
+ *   - Default: the full result is recorded as a single row in the
+ *     `improve_runs` table of `state.db` (migration 003). Stdout is empty.
+ *     The existing `[improve] ...` progress log lines on stderr remain the
+ *     canonical console UX.
+ *   - `--json-to-stdout` restores the prior behaviour: full JSON to stdout,
+ *     nothing written to state.db.
+ *
+ * v0.8.0 storage change (this module): the previous on-disk artifact at
+ * `<stash>/.akm/runs/<runId>/improve-result.json` is no longer written. The
+ * canonical record now lives in `improve_runs` (see
+ * `src/core/state-db.ts`). Pre-existing files from older runs are not
+ * deleted by this change — they become historical artifacts. Zero current
+ * code paths read them, so no consumers needed to update.
+ *
+ * Run-id format: ISO-8601 timestamp (colons/dots replaced by `-`) plus an
+ * 8-char hex random suffix. There is no existing canonical run-id helper for
+ * persistent per-command artefacts on disk — the `workflow_runs` table uses
+ * `randomUUID()` but is database-scoped, and `consolidate-journal.json` is a
+ * single-slot artefact. We mint a fresh timestamped id for each improve run.
+ */
+import crypto from "node:crypto";
+import path from "node:path";
+import { openStateDatabase, recordImproveRun } from "../core/state-db";
+/**
+ * Build a stable run-id for a single improve invocation.
+ *
+ * Shape: `<iso-8601-utc-with-dashes>-<8 hex chars>`, e.g.
+ *   `2026-05-19T17-30-22-123Z-a1b2c3d4`.
+ *
+ * The hex suffix protects against same-millisecond collisions when multiple
+ * runs happen back-to-back in tests or scripts.
+ */
+export function buildImproveRunId(now = new Date()) {
+    const iso = now.toISOString().replace(/[:.]/g, "-");
+    const rand = crypto.randomBytes(4).toString("hex");
+    return `${iso}-${rand}`;
+}
+/**
+ * Return a stable, human-recognisable reference for a given improve run.
+ *
+ * Historical compatibility shim: callers used to receive a stash-relative
+ * file path like `.akm/runs/<runId>/improve-result.json`. With the state.db
+ * migration, no such file exists, but several callers still log "wrote to
+ * <path>" style messages. Returning a `state.db//improve_runs/<runId>`
+ * locator preserves the "the result is at <thing>" signature so existing
+ * log lines and error messages continue to make sense without rewriting
+ * every call site.
+ */
+export function relativeImproveResultPath(runId) {
+    return path.join("state.db", "improve_runs", runId);
+}
+/**
+ * Persist the full improve result into the `improve_runs` table of state.db.
+ *
+ * Backwards-compatible signature: the function name, argument list, and
+ * return type all match the pre-0.8.0 file-writing helper. The returned
+ * string is the `state.db//improve_runs/<runId>` locator (see
+ * {@link relativeImproveResultPath}), which is intended for log messages
+ * only — no caller should treat it as a filesystem path. Zero current
+ * readers existed for the previous file path, so this is a pure storage
+ * swap.
+ *
+ * The state.db row carries the scope and dry-run flag from `result.scope`
+ * and `result.dryRun`, plus the full result JSON for full fidelity. The
+ * dry-run column is indexed so productivity audits can filter cleanly
+ * (closes the dry-run/real-run artifact-trap recorded in MEMORY.md
+ * `feedback_akm_dryrun_artifact_trap`).
+ */
+export function writeImproveResultFile(stashDir, runId, result) {
+    const db = openStateDatabase();
+    try {
+        const startedAt = new Date().toISOString();
+        recordImproveRun(db, {
+            id: runId,
+            startedAt,
+            completedAt: startedAt,
+            stashDir,
+            dryRun: Boolean(result.dryRun),
+            profile: null,
+            scopeMode: result.scope?.mode ?? "all",
+            scopeValue: result.scope?.value ?? null,
+            guidance: result.guidance ?? null,
+            ok: Boolean(result.ok),
+            result,
+        });
+    }
+    finally {
+        try {
+            db.close();
+        }
+        catch {
+            // best-effort
+        }
+    }
+    return relativeImproveResultPath(runId);
+}