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

package/dist/commands/proposal/legacy-import.js

@@ -1,115 +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/.
-/**
- * Legacy filesystem proposal import (#578).
- *
- * Before 0.9.0 proposals lived as per-uuid JSON directories under
- * `<stashDir>/.akm/proposals/` (live) and `…/proposals/archive/` (archived).
- * The first proposal operation against a stash imports any legacy
- * `proposal.json` files into the `proposals` table (INSERT OR IGNORE keyed on
- * the UUID, so re-runs never duplicate) and records the stash in
- * `proposal_fs_imports` so later invocations skip the directory walk. The
- * legacy files are left in place untouched — they are inert after import and
- * may be removed by the operator at leisure.
- */
-import fs from "node:fs";
-import path from "node:path";
-import { warn } from "../../core/warn.js";
-import { hasImportedFsProposals, insertProposalIfAbsent, recordFsProposalsImport, } from "../../storage/repositories/proposals-repository.js";
-/** Legacy (pre-0.9.0) proposal directory: `<stashDir>/.akm/proposals[/archive]`. */
-function legacyProposalsRoot(stashDir, archive) {
-    const root = path.join(stashDir, ".akm", "proposals");
-    return archive ? path.join(root, "archive") : root;
-}
-/**
- * One-shot import of legacy `proposal.json` files into the `proposals` table.
- *
- * Idempotent at two levels: the `proposal_fs_imports` ledger skips the
- * directory walk after the first successful import, and INSERT OR IGNORE
- * (keyed on the proposal UUID) protects against duplicates even if the walk
- * re-runs. Legacy `backup.<ext>` files are inlined into `backupContent` so
- * `akm proposal revert` keeps working for proposals accepted before 0.9.0.
- *
- * The legacy files are never modified or deleted — after import they are
- * inert artifacts the operator can remove at leisure.
- */
-export function importLegacyProposalFiles(db, stashDir) {
-    if (hasImportedFsProposals(db, stashDir))
-        return;
-    const liveRoot = legacyProposalsRoot(stashDir, false);
-    if (!fs.existsSync(liveRoot))
-        return;
-    let imported = 0;
-    for (const archive of [false, true]) {
-        const root = legacyProposalsRoot(stashDir, archive);
-        let entries;
-        try {
-            entries = fs.readdirSync(root, { withFileTypes: true });
-        }
-        catch {
-            continue;
-        }
-        for (const entry of entries) {
-            if (!entry.isDirectory() || entry.name === "archive")
-                continue;
-            const proposalDir = path.join(root, entry.name);
-            const proposal = readLegacyProposalFile(proposalDir);
-            if (!proposal)
-                continue;
-            if (insertProposalIfAbsent(db, proposal, stashDir))
-                imported += 1;
-        }
-    }
-    recordFsProposalsImport(db, stashDir, imported);
-    if (imported > 0) {
-        warn(`[proposals] imported ${imported} legacy proposal file(s) from ${liveRoot} into state.db`);
-    }
-}
-/**
- * Parse one legacy proposal directory into a {@link Proposal}, inlining the
- * backup file (when present) as `backupContent`. Returns undefined — with a
- * warning — when the `proposal.json` is missing, unreadable, or malformed, so
- * a single corrupt legacy entry never blocks the import of the rest.
- */
-function readLegacyProposalFile(proposalDir) {
-    const filePath = path.join(proposalDir, "proposal.json");
-    let parsed;
-    try {
-        parsed = JSON.parse(fs.readFileSync(filePath, "utf8"));
-    }
-    catch (err) {
-        warn(`[proposals] skipping legacy proposal at ${filePath}: ${err instanceof Error ? err.message : String(err)}`);
-        return undefined;
-    }
-    if (typeof parsed !== "object" ||
-        parsed === null ||
-        typeof parsed.id !== "string" ||
-        typeof parsed.ref !== "string") {
-        warn(`[proposals] skipping legacy proposal at ${filePath}: not a proposal object`);
-        return undefined;
-    }
-    const { backup, ...rest } = parsed;
-    let backupContent;
-    if (typeof backup === "string" && backup.length > 0) {
-        try {
-            backupContent = fs.readFileSync(path.join(proposalDir, backup), "utf8");
-        }
-        catch {
-            // Backup file lost — import the proposal anyway; revert for it will
-            // surface "no backup available", same as a new-asset proposal.
-        }
-    }
-    return {
-        ...rest,
-        payload: {
-            content: rest.payload?.content ?? "",
-            ...(rest.payload?.frontmatter ? { frontmatter: rest.payload.frontmatter } : {}),
-        },
-        createdAt: rest.createdAt ?? "",
-        updatedAt: rest.updatedAt ?? rest.createdAt ?? "",
-        status: rest.status ?? "pending",
-        source: rest.source ?? "import",
-        ...(backupContent !== undefined ? { backupContent } : {}),
-    };
-}

package/dist/commands/sources/history.js

@@ -1,196 +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/.
-/**
- * `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.
- */
-import { parseAssetRef } from "../../core/asset/asset-ref.js";
-import { UsageError } from "../../core/errors.js";
-import { readEvents } from "../../core/events.js";
-import { isoToSqlite, parseSinceToIso } from "../../core/time.js";
-import { closeDatabase, openExistingDatabase } from "../../indexer/db/db.js";
-import { getUsageEvents } from "../../indexer/usage/usage-events.js";
-import { listProposals } from "../proposal/repository.js";
-// Proposal lifecycle event types emitted by the proposal substrate (#225).
-const PROPOSAL_EVENT_TYPES = new Set(["promoted", "rejected"]);
-// ── Helpers ──────────────────────────────────────────────────────────────────
-function parseMetadata(raw) {
-    if (!raw)
-        return null;
-    try {
-        return JSON.parse(raw);
-    }
-    catch {
-        return raw;
-    }
-}
-function toEntry(row) {
-    return {
-        id: row.id,
-        eventType: row.event_type,
-        ref: row.entry_ref,
-        entryId: row.entry_id,
-        query: row.query,
-        signal: row.signal,
-        source: row.source,
-        metadata: parseMetadata(row.metadata),
-        createdAt: row.created_at,
-    };
-}
-/**
- * Convert an ISO timestamp from events.jsonl ("2026-04-01T12:00:00.000Z")
- * to the SQLite-style format used in HistoryEntry.createdAt
- * ("2026-04-01 12:00:00") so entries sort consistently.
- */
-function isoToSqliteTimestamp(ts) {
-    // Normalise to the "YYYY-MM-DD HH:MM:SS" format used by usage_events rows.
-    return ts
-        .replace("T", " ")
-        .replace(/\.\d+Z$/, "")
-        .replace("Z", "");
-}
-// ── Main ─────────────────────────────────────────────────────────────────────
-/**
- * Read mutation/usage history. When `ref` is provided, results are filtered to
- * that asset (validated via `parseAssetRef`). Always returns chronological
- * order (oldest first) so consumers can display a lifecycle trail.
- *
- * When `includeProposals` is true, proposal lifecycle events (`promoted`,
- * `rejected`) from events.jsonl are merged into the result set. This provides
- * one coherent view of both usage signals and proposal review decisions.
- */
-export async function akmHistory(options = {}) {
-    let normalizedRef;
-    if (options.ref !== undefined) {
-        const trimmed = options.ref.trim();
-        if (!trimmed) {
-            throw new UsageError("--ref cannot be empty.", "INVALID_FLAG_VALUE");
-        }
-        // Validate the ref grammar; we still query by exact entry_ref string so
-        // the user gets back exactly what they asked for.
-        parseAssetRef(trimmed);
-        normalizedRef = trimmed;
-    }
-    const sinceNormalized = options.since !== undefined ? isoToSqlite(parseSinceToIso(options.since)) : undefined;
-    const db = options.db ?? openExistingDatabase();
-    const ownsDb = options.db === undefined;
-    try {
-        const rows = getUsageEvents(db, {
-            entry_ref: normalizedRef,
-            since: sinceNormalized,
-            source: options.source,
-        });
-        const usageEntries = rows.map(toEntry);
-        // ── Proposal lifecycle events (opt-in) ────────────────────────────────
-        const sources = ["usage_events"];
-        const proposalEntries = [];
-        if (options.includeProposals === true) {
-            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;
-            const { events } = readEvents({
-                since: sinceIso,
-                ref: normalizedRef,
-            }, options.eventsCtx);
-            // Keep only proposal lifecycle event types.
-            let counter = -1_000_000; // negative ids mark proposal-stream entries
-            for (const event of events) {
-                if (!PROPOSAL_EVENT_TYPES.has(event.eventType))
-                    continue;
-                const createdAt = event.ts ? isoToSqliteTimestamp(event.ts) : "";
-                // Skip if before `since` (readEvents already filters by ts >= since,
-                // but the isoToSqliteTimestamp conversion may introduce drift so we
-                // guard again with the normalised form).
-                if (sinceNormalized !== undefined && createdAt < sinceNormalized)
-                    continue;
-                proposalEntries.push({
-                    id: counter--,
-                    eventType: event.eventType,
-                    ref: event.ref ?? null,
-                    entryId: null,
-                    query: null,
-                    signal: null,
-                    source: null,
-                    metadata: event.metadata ?? null,
-                    createdAt,
-                });
-            }
-        }
-        // ── Merge and sort ────────────────────────────────────────────────────
-        const entries = [...usageEntries, ...proposalEntries].sort((a, b) => {
-            // Primary sort: chronological by createdAt (string compare is safe for
-            // "YYYY-MM-DD HH:MM:SS" format). Secondary sort: id ascending for ties.
-            if (a.createdAt < b.createdAt)
-                return -1;
-            if (a.createdAt > b.createdAt)
-                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 } : {}),
-            ...(sinceNormalized !== undefined ? { since: sinceNormalized } : {}),
-            totalCount: entries.length,
-            entries,
-            sources,
-            ...(acceptRateBySource !== undefined ? { acceptRateBySource } : {}),
-        };
-        return response;
-    }
-    finally {
-        if (ownsDb)
-            closeDatabase(db);
-    }
-}

package/dist/commands/tasks/default-tasks.js

@@ -1,186 +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/.
-/**
- * Default scheduled-task set for the improve pipeline (issue #552).
- *
- * Ships a well-tuned multi-cadence task set so a typical single-developer
- * install is correct with zero manual config. Registration is **idempotent**:
- * running `akm setup` / `akm tasks init` twice yields the same task set with no
- * duplicates. Each default task is a shell-command task (`akm improve --profile
- * <name>`), so the profile is overridable in `config.json` without editing the
- * task definition.
- *
- * The OS-scheduler-touching primitives (`add` / `setEnabled` / `list`) are
- * injected via {@link RegisterDefaultTasksDeps} so tests can supply fakes and
- * never mutate the host scheduler or a real stash — mirroring the
- * dependency-injection pattern used by `stepScheduledTasks` in setup.ts.
- */
-import fs from "node:fs";
-import os from "node:os";
-import { akmTasksAdd, akmTasksList } from "./tasks.js";
-/**
- * The canonical default improve task set. The `update-stashes` embedded core
- * template (nightly `akm update --all`) was retired in meta-review 06-M2:
- * third-party stash pulls are on-demand only now, not a scheduled cron.
- */
-export const DEFAULT_IMPROVE_TASKS = [
-    {
-        id: "akm-improve-frequent",
-        profile: "frequent",
-        command: "akm improve --profile frequent --auto-accept safe",
-        schedule: "0 * * * *",
-        description: "Frequent extract + inference pass (every 60 min)",
-        enableMode: "always",
-    },
-    {
-        id: "akm-improve-consolidate",
-        profile: "consolidate",
-        command: "akm improve --profile consolidate --auto-accept safe",
-        schedule: "0 */4 * * *",
-        description: "Consolidation-only pass (every 4h)",
-        enableMode: "always",
-    },
-    {
-        id: "akm-improve-nightly",
-        profile: "thorough",
-        command: "akm improve --profile thorough --auto-accept safe",
-        schedule: "0 2 * * *",
-        description: "Full nightly quality sweep (daily 2am)",
-        enableMode: "server",
-    },
-    {
-        id: "akm-improve-catchup",
-        profile: "catchup",
-        command: "akm improve --profile catchup --auto-accept safe",
-        schedule: null,
-        description: "Manual recovery — consolidation + triage drain (run on demand)",
-        enableMode: "manual",
-    },
-    {
-        id: "akm-graph-refresh-weekly",
-        profile: "graph-refresh",
-        command: "akm improve --profile graph-refresh --auto-accept safe",
-        schedule: "0 3 * * 0",
-        description: "Full-corpus graph rebuild (weekly Sunday 3am)",
-        enableMode: "always",
-    },
-];
-/**
- * A schedule for the manual catch-up task. The scheduler requires a valid
- * cron expression even when the task is registered disabled, so we give the
- * unscheduled task a nominal far-future-ish cadence and leave it disabled —
- * the documented entry point is `akm tasks run akm-improve-catchup`.
- */
-const MANUAL_TASK_NOMINAL_SCHEDULE = "0 4 1 1 *"; // 04:00 on Jan 1 — never effectively fires
-const DEFAULT_DEPS = {
-    list: akmTasksList,
-    add: akmTasksAdd,
-};
-let defaultTasksOverrides;
-/** TEST-ONLY. Swap the CI/server/register functions; pass undefined to restore. */
-export function _setDefaultTasksForTests(fakes) {
-    defaultTasksOverrides = fakes;
-}
-/**
- * Decide whether `akm setup` is running in a CI environment, where it must
- * register NO scheduled tasks. Mirrors the common `CI=true` convention used by
- * GitHub Actions, GitLab CI, CircleCI, etc.
- */
-export function isCiEnvironment(env = process.env) {
-    if (defaultTasksOverrides?.isCiEnvironment)
-        return defaultTasksOverrides.isCiEnvironment(env);
-    const ci = env.CI;
-    if (ci === undefined || ci === null)
-        return false;
-    const v = String(ci).trim().toLowerCase();
-    return v !== "" && v !== "0" && v !== "false";
-}
-/**
- * Platform-appropriate default for the "Is this a server install?" prompt:
- *  - Linux without a battery → `true` (server).
- *  - macOS / any host with a battery (laptop) → `false`.
- * Used as the default when setup is non-interactive (no TTY / --yes / CI).
- */
-export function detectServerDefault() {
-    if (defaultTasksOverrides?.detectServerDefault)
-        return defaultTasksOverrides.detectServerDefault();
-    if (os.platform() !== "linux")
-        return false;
-    // A laptop exposes a battery under /sys/class/power_supply/BAT*. Absence of
-    // any battery is our heuristic for "server / desktop".
-    try {
-        const entries = fs.readdirSync("/sys/class/power_supply");
-        const hasBattery = entries.some((e) => /^BAT/i.test(e));
-        return !hasBattery;
-    }
-    catch {
-        // If we cannot read power-supply info, prefer the safe server default on
-        // Linux (the nightly sweep is low-impact and re-runnable).
-        return true;
-    }
-}
-/**
- * Idempotently register the default improve task set.
- *
- * - Skips entirely when `CI` is set (returns `{ skipped: true, reason: "ci" }`).
- * - Creates any missing task; never duplicates an existing one.
- * - Re-aligns the enabled-state of existing tasks to the desired default only
- *   when the install is fresh-creating them (existing tasks the user may have
- *   toggled are left untouched — we only toggle tasks we just created, plus we
- *   never re-disable a user-enabled task).
- */
-export async function registerDefaultTasks(options = {}) {
-    if (defaultTasksOverrides?.registerDefaultTasks) {
-        return defaultTasksOverrides.registerDefaultTasks(options);
-    }
-    if (isCiEnvironment()) {
-        return { skipped: true, reason: "ci", created: [], existing: [], toggled: [] };
-    }
-    const deps = options.deps ?? DEFAULT_DEPS;
-    const serverInstall = options.serverInstall ?? detectServerDefault();
-    let installed = [];
-    try {
-        installed = (await deps.list()).tasks;
-    }
-    catch {
-        installed = [];
-    }
-    const existingIds = new Set(installed.map((t) => t.id));
-    const created = [];
-    const existing = [];
-    const toggled = [];
-    for (const spec of DEFAULT_IMPROVE_TASKS) {
-        const desiredEnabled = resolveDesiredEnabled(spec, serverInstall);
-        if (existingIds.has(spec.id)) {
-            // Idempotent: never re-create. Leave the existing task in place.
-            existing.push(spec.id);
-            continue;
-        }
-        const schedule = spec.schedule ?? MANUAL_TASK_NOMINAL_SCHEDULE;
-        const addInput = {
-            id: spec.id,
-            schedule,
-            command: spec.command,
-            description: spec.description,
-            // Manual + non-server-enabled tasks are written disabled so the
-            // scheduler entry is inert until the user opts in / runs it manually.
-            disabled: !desiredEnabled,
-        };
-        await deps.add(addInput);
-        created.push(spec.id);
-        if (desiredEnabled)
-            toggled.push(spec.id);
-    }
-    return { skipped: false, created, existing, toggled };
-}
-function resolveDesiredEnabled(spec, serverInstall) {
-    switch (spec.enableMode) {
-        case "always":
-            return true;
-        case "server":
-            return serverInstall;
-        case "manual":
-            return false;
-    }
-}