akm-cli 0.9.17-alpha.1 → 0.9.17-alpha.10

package/dist/commands/proposal/drain-policies.js

@@ -1,151 +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/.
-/**
- * Built-in deterministic triage policy presets (Proposal-Queue Triage, §3.1).
- *
- * These are the *only* "rule schema" we ship. Custom needs are served by the
- * single `--policy <path>` escape hatch, which zod-validates an external policy
- * file — not by a config-embedded rule engine (see §9, rejected alternatives).
- *
- * | preset           | accepts                                                   | rejects     | leaves pending                                     |
- * |------------------|-----------------------------------------------------------|-------------|----------------------------------------------------|
- * | `personal-stash` | extract (real content); reflect ≤80 lines; consolidate    | empty diffs | consolidate mid-band, distill dups, contradictions |
- * | `conservative`   | small extract + consolidate only                          | empty diffs | everything else                                    |
- * | `manual`         | nothing                                                   | empty diffs | everything else                                    |
- */
-import fs from "node:fs";
-import { z } from "zod";
-import { UsageError } from "../../core/errors.js";
-import { warnOnce } from "../../core/warn.js";
-import { PROPOSAL_SOURCES } from "./repository.js";
-// Valid `generator` values for a drain rule are exactly the canonical proposal
-// `source` values (see {@link PROPOSAL_SOURCES} in src/commands/proposal/repository.ts). The
-// engine matches rules via `policy.accept.find(r => r.generator === proposal.source)`,
-// so a generator that is not a real source can never match — it would be a
-// silent permanent no-op. Validate against the closed set to surface typos.
-const GeneratorSchema = z.enum(PROPOSAL_SOURCES, {
-    errorMap: () => ({
-        message: `must be one of the known proposal sources: ${PROPOSAL_SOURCES.join(", ")}`,
-    }),
-});
-// ---------------------------------------------------------------------------
-// Built-in presets
-// ---------------------------------------------------------------------------
-/**
- * `personal-stash` encodes the deterministic core of today's hand-rolled
- * rubric (the editable `contradicted` memory). It is shipped as a preset, never
- * hardcoded policy: edit a copy via `--policy <path>` to tune it.
- */
-export const PERSONAL_STASH = {
-    name: "personal-stash",
-    accept: [
-        // Extract proposals carry freshly-pulled real content — accept when present,
-        // but cap the diff for parity with reflect(80)/consolidate(200): an
-        // arbitrarily large extract should not auto-promote with zero LLM calls.
-        { generator: "extract", minContentLines: 1, maxDiffLines: 200 },
-        // Reflect refinements: accept small ones; larger refinements defer to review.
-        { generator: "reflect", maxDiffLines: 80 },
-        // Consolidate within the diff band; mid-band lands in `defer` below.
-        { generator: "consolidate", maxDiffLines: 200 },
-    ],
-    rejectEmpty: true,
-    // Mid-band consolidate, distill duplicates, and contradiction escalations are
-    // the irreducibly-semantic tail — deferred to the (Phase 3) judgment tier.
-    defer: ["consolidate", "distill"],
-};
-/** `conservative` accepts only small, low-risk extract + consolidate proposals. */
-export const CONSERVATIVE = {
-    name: "conservative",
-    accept: [
-        { generator: "extract", maxDiffLines: 80, minContentLines: 1 },
-        { generator: "consolidate", maxDiffLines: 80 },
-    ],
-    rejectEmpty: true,
-    defer: [],
-};
-/** `manual` accepts nothing; it only clears empty diffs. */
-export const MANUAL = {
-    name: "manual",
-    accept: [],
-    rejectEmpty: true,
-    defer: [],
-};
-const BUILTIN_POLICIES = {
-    "personal-stash": PERSONAL_STASH,
-    conservative: CONSERVATIVE,
-    manual: MANUAL,
-};
-/** Names of the built-in presets, for help text and validation messages. */
-export const BUILTIN_POLICY_NAMES = Object.keys(BUILTIN_POLICIES);
-// ---------------------------------------------------------------------------
-// Custom policy file schema (`--policy <path>`)
-// ---------------------------------------------------------------------------
-const DrainAcceptRuleSchema = z
-    .object({
-    generator: GeneratorSchema,
-    maxDiffLines: z.number().int().positive().optional(),
-    minContentLines: z.number().int().nonnegative().optional(),
-    requireType: z.string().optional(),
-})
-    .passthrough();
-const DrainPolicySchema = z
-    .object({
-    name: z.string().min(1),
-    accept: z.array(DrainAcceptRuleSchema),
-    rejectEmpty: z.boolean(),
-    defer: z.array(GeneratorSchema),
-})
-    .passthrough();
-function warnIgnoredPolicyKeys(filePath, label, raw, knownKeys) {
-    if (!raw || typeof raw !== "object" || Array.isArray(raw))
-        return;
-    const extra = Object.keys(raw).filter((key) => !knownKeys.includes(key));
-    if (extra.length === 0)
-        return;
-    warnOnce(`drain-policy-ignored-keys:${filePath}:${label}:${extra.join(",")}`, `[proposal] Policy file "${filePath}" has ${label} field(s) akm does not recognize and ignores: ${extra.join(", ")}. Check for a typo, or the file may be written for a newer akm version.`);
-}
-const DRAIN_POLICY_KNOWN_KEYS = Object.keys(DrainPolicySchema.shape);
-const DRAIN_ACCEPT_RULE_KNOWN_KEYS = Object.keys(DrainAcceptRuleSchema.shape);
-/**
- * Resolve a `--policy <preset|path>` argument into a {@link DrainPolicy}.
- *
- *   - A bare preset name (`personal-stash` / `conservative` / `manual`) returns
- *     the matching built-in.
- *   - Anything else is treated as a filesystem path to a JSON policy file, which
- *     is read and zod-validated.
- *
- * Throws a {@link UsageError} on an unknown preset, a missing file, or a file
- * that fails schema validation.
- */
-export function resolveDrainPolicy(arg) {
-    const value = (arg ?? "personal-stash").trim();
-    const builtin = BUILTIN_POLICIES[value];
-    if (builtin)
-        return builtin;
-    // Treat as a path to a custom policy file.
-    if (!fs.existsSync(value)) {
-        throw new UsageError(`Unknown policy "${value}". Use a built-in preset (${BUILTIN_POLICY_NAMES.join(", ")}) or a path to a policy file.`, "INVALID_FLAG_VALUE");
-    }
-    let parsed;
-    try {
-        parsed = JSON.parse(fs.readFileSync(value, "utf8"));
-    }
-    catch (err) {
-        throw new UsageError(`Could not parse policy file "${value}": ${err instanceof Error ? err.message : String(err)}`, "INVALID_FLAG_VALUE");
-    }
-    const validated = DrainPolicySchema.safeParse(parsed);
-    if (!validated.success) {
-        throw new UsageError(`Invalid policy file "${value}": ${validated.error.issues.map((i) => `${i.path.join(".") || "<root>"}: ${i.message}`).join("; ")}`, "INVALID_FLAG_VALUE");
-    }
-    warnIgnoredPolicyKeys(value, "top-level", parsed, DRAIN_POLICY_KNOWN_KEYS);
-    if (parsed &&
-        typeof parsed === "object" &&
-        !Array.isArray(parsed) &&
-        Array.isArray(parsed.accept)) {
-        parsed.accept.forEach((rule, index) => {
-            warnIgnoredPolicyKeys(value, `accept[${index}]`, rule, DRAIN_ACCEPT_RULE_KNOWN_KEYS);
-        });
-    }
-    return validated.data;
-}

package/dist/commands/sources/update-transaction.js

@@ -1,220 +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 { randomBytes } from "node:crypto";
-import fs from "node:fs";
-import path from "node:path";
-import { ConfigError } from "../../core/errors.js";
-import { warn } from "../../core/warn.js";
-import { runGit } from "../../sources/providers/git.js";
-import { assertNoIgnoredPathOverwrite } from "../../sources/providers/git-install.js";
-export function prepareDirectoryPublication(stagedRoot, liveRoot) {
-    const backupRoot = `${liveRoot}.akm-update-backup-${randomBytes(6).toString("hex")}`;
-    let published = false;
-    let hadLiveRoot = false;
-    return {
-        publish() {
-            if (published)
-                throw new ConfigError(`Update content at ${liveRoot} was already published.`);
-            hadLiveRoot = fs.existsSync(liveRoot);
-            fs.mkdirSync(path.dirname(liveRoot), { recursive: true });
-            if (hadLiveRoot)
-                fs.renameSync(liveRoot, backupRoot);
-            try {
-                fs.renameSync(stagedRoot, liveRoot);
-                published = true;
-            }
-            catch (error) {
-                if (hadLiveRoot && fs.existsSync(backupRoot))
-                    fs.renameSync(backupRoot, liveRoot);
-                throw error;
-            }
-        },
-        rollback() {
-            if (!published)
-                return;
-            const failedRoot = `${liveRoot}.akm-update-failed-${randomBytes(6).toString("hex")}`;
-            if (fs.existsSync(liveRoot))
-                fs.renameSync(liveRoot, failedRoot);
-            try {
-                if (hadLiveRoot && fs.existsSync(backupRoot))
-                    fs.renameSync(backupRoot, liveRoot);
-            }
-            catch (error) {
-                // The prior generation could not be restored. Put the published
-                // candidate back at the live path so resolution never sees a missing
-                // root, then surface the rollback failure loudly.
-                try {
-                    if (!fs.existsSync(liveRoot) && fs.existsSync(failedRoot))
-                        fs.renameSync(failedRoot, liveRoot);
-                }
-                catch {
-                    // Preserve the original restoration failure; both paths remain for
-                    // manual recovery when even the defensive rename cannot complete.
-                }
-                published = false;
-                throw error;
-            }
-            try {
-                fs.rmSync(failedRoot, { recursive: true, force: true });
-            }
-            catch (error) {
-                warn(`[akm bundle update] restored ${liveRoot}, but could not remove failed candidate ${failedRoot}: ${error instanceof Error ? error.message : String(error)}`);
-            }
-            published = false;
-        },
-        commit() {
-            if (hadLiveRoot) {
-                try {
-                    fs.rmSync(backupRoot, { recursive: true, force: true });
-                }
-                catch (error) {
-                    warn(`[akm bundle update] update committed, but could not remove backup ${backupRoot}: ${error instanceof Error ? error.message : String(error)}`);
-                }
-            }
-            published = false;
-        },
-    };
-}
-function gitOutput(repoDir, args, description) {
-    const result = runGit(["-C", repoDir, ...args], { timeout: 120_000 });
-    if (result.status !== 0) {
-        throw new ConfigError(`${description}: ${result.stderr.trim() || result.stdout.trim() || "git failed"}`);
-    }
-    return result.stdout.trim();
-}
-function assertGitCheckoutGeneration(repoDir, expectedHead, phase) {
-    const actualHead = gitOutput(repoDir, ["rev-parse", "HEAD"], `Cannot read writable Git HEAD at ${repoDir}`);
-    if (actualHead !== expectedHead) {
-        throw new ConfigError(`Writable Git checkout at ${repoDir} changed after the update was audited (${phase}: expected ${expectedHead}, found ${actualHead}); refusing to overwrite the live commit.`);
-    }
-    const status = gitOutput(repoDir, ["status", "--porcelain=v1", "--untracked-files=all", "--ignore-submodules=none"], `Cannot inspect writable Git checkout at ${repoDir}`);
-    if (status) {
-        throw new ConfigError(`Writable Git checkout at ${repoDir} changed after the update was audited (${phase}: working tree is no longer clean); refusing to overwrite live files.`);
-    }
-}
-function assertNoGitlinks(repoDir, targetHead) {
-    const tree = gitOutput(repoDir, ["ls-tree", "-r", "-z", targetHead], `Cannot inspect audited Git tree ${targetHead} at ${repoDir}`);
-    const gitlink = tree.split("\0").find((entry) => entry.startsWith("160000 "));
-    if (gitlink) {
-        const targetPath = gitlink.slice(gitlink.indexOf("\t") + 1);
-        throw new ConfigError(`Writable Git target contains unaudited submodule/gitlink ${targetPath}; refusing to materialize it.`);
-    }
-}
-function copyWorktree(source, destination) {
-    fs.mkdirSync(destination, { recursive: true, mode: 0o700 });
-    for (const entry of fs.readdirSync(source, { withFileTypes: true })) {
-        if (entry.name === ".git")
-            continue;
-        fs.cpSync(path.join(source, entry.name), path.join(destination, entry.name), {
-            recursive: true,
-            preserveTimestamps: true,
-        });
-    }
-}
-function clearWorktree(repoDir) {
-    for (const entry of fs.readdirSync(repoDir, { withFileTypes: true })) {
-        if (entry.name === ".git")
-            continue;
-        fs.rmSync(path.join(repoDir, entry.name), { recursive: true, force: true });
-    }
-}
-/**
- * Publish the exact audited commit into a writable checkout without replacing
- * the checkout directory. The expected-old-HEAD and clean-tree fence runs
- * under the caller's asset mutation lease immediately before the fast-forward.
- */
-export function prepareWritableGitPublication(opts) {
-    let published = false;
-    let rollbackParent;
-    let rollbackWorktree;
-    const discardRollback = () => {
-        if (!rollbackParent)
-            return;
-        cleanupStagingParent(rollbackParent);
-        rollbackParent = undefined;
-        rollbackWorktree = undefined;
-    };
-    const restore = () => {
-        if (!rollbackWorktree)
-            return;
-        const actualHead = gitOutput(opts.liveRepo, ["rev-parse", "HEAD"], `Cannot read writable Git rollback HEAD`);
-        if (actualHead !== opts.expectedOldHead && actualHead !== opts.auditedTargetHead) {
-            throw new ConfigError(`Writable Git checkout ${opts.liveRepo} advanced concurrently to ${actualHead}; refusing to overwrite that commit during rollback.`);
-        }
-        gitOutput(opts.liveRepo, ["reset", "--hard", opts.expectedOldHead], `Cannot restore writable Git checkout ${opts.liveRepo} to ${opts.expectedOldHead}`);
-        clearWorktree(opts.liveRepo);
-        copyWorktree(rollbackWorktree, opts.liveRepo);
-        assertGitCheckoutGeneration(opts.liveRepo, opts.expectedOldHead, "rollback verification");
-        published = false;
-        discardRollback();
-    };
-    return {
-        publish() {
-            if (published)
-                throw new ConfigError(`Writable Git update at ${opts.liveRepo} was already published.`);
-            assertGitCheckoutGeneration(opts.liveRepo, opts.expectedOldHead, "pre-publish fence");
-            assertGitCheckoutGeneration(opts.stagedRepo, opts.auditedTargetHead, "staged audit fence");
-            const ancestor = runGit([
-                "-C",
-                opts.stagedRepo,
-                "merge-base",
-                "--is-ancestor",
-                opts.expectedOldHead,
-                opts.auditedTargetHead,
-            ]);
-            if (ancestor.status !== 0) {
-                throw new ConfigError(`Audited Git target ${opts.auditedTargetHead} is not a fast-forward of live HEAD ${opts.expectedOldHead}; refusing writable update.`);
-            }
-            assertNoGitlinks(opts.stagedRepo, opts.auditedTargetHead);
-            gitOutput(opts.liveRepo, ["fetch", "--no-tags", opts.stagedRepo, opts.auditedTargetHead], `Cannot import audited Git target ${opts.auditedTargetHead} into ${opts.liveRepo}`);
-            // A non-cooperating local Git command may have committed while fetch ran.
-            assertGitCheckoutGeneration(opts.liveRepo, opts.expectedOldHead, "post-fetch fence");
-            assertNoIgnoredPathOverwrite(opts.liveRepo, opts.auditedTargetHead);
-            rollbackParent = createStagingParent(path.dirname(opts.liveRepo));
-            rollbackWorktree = path.join(rollbackParent, "worktree");
-            try {
-                copyWorktree(opts.liveRepo, rollbackWorktree);
-            }
-            catch (error) {
-                discardRollback();
-                throw error;
-            }
-            try {
-                gitOutput(opts.liveRepo, ["merge", "--ff-only", "--no-overwrite-ignore", opts.auditedTargetHead], `Cannot fast-forward writable Git checkout ${opts.liveRepo}`);
-                published = true;
-                assertGitCheckoutGeneration(opts.liveRepo, opts.auditedTargetHead, "post-materialization fence");
-            }
-            catch (error) {
-                try {
-                    restore();
-                }
-                catch (restoreError) {
-                    throw new ConfigError(`Writable Git publication failed and its worktree could not be restored: ${restoreError instanceof Error ? restoreError.message : String(restoreError)}`);
-                }
-                throw error;
-            }
-        },
-        rollback() {
-            if (!published)
-                return;
-            restore();
-        },
-        commit() {
-            published = false;
-            discardRollback();
-        },
-    };
-}
-export function createStagingParent(parent) {
-    fs.mkdirSync(parent, { recursive: true, mode: 0o700 });
-    return fs.mkdtempSync(path.join(parent, ".akm-update-stage-"));
-}
-export function cleanupStagingParent(stagingParent) {
-    try {
-        fs.rmSync(stagingParent, { recursive: true, force: true });
-    }
-    catch (error) {
-        warn(`[akm bundle update] could not remove staging directory ${stagingParent}: ${error instanceof Error ? error.message : String(error)}`);
-    }
-}

package/dist/core/action-contributors.js

@@ -1,28 +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 { defaultRendererRegistry } from "./type-presentation.js";
-function registryActionContributor(registry) {
-    return {
-        name: "registry-action-contributor",
-        appliesTo(ctx) {
-            return registry.actionBuilderFor(ctx.type) !== undefined;
-        },
-        buildAction(ctx) {
-            return registry.actionBuilderFor(ctx.type)?.(ctx.ref);
-        },
-    };
-}
-export function defaultActionContributors(registry = defaultRendererRegistry) {
-    return [registryActionContributor(registry)];
-}
-export function buildActionFromContributors(ctx, contributors = defaultActionContributors()) {
-    for (const contributor of contributors) {
-        if (!contributor.appliesTo(ctx))
-            continue;
-        const action = contributor.buildAction(ctx);
-        if (action !== undefined)
-            return action;
-    }
-    return undefined;
-}

package/dist/core/config/config-version-shim.js

@@ -1,101 +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/.
-/**
- * The `configVersion` read shim (#863).
- *
- * `configVersion` used to be a hard `z.literal(CURRENT_CONFIG_VERSION)` gate:
- * every value other than the exact current string threw
- * `UNSUPPORTED_CONFIG_VERSION` for every command, since every akm invocation
- * loads config first. That is the same shape of break #858/#859 (proposal
- * rows), the `task_history` `metadataVersion` gate, and the task-source v2/v3
- * gate each caused in 0.9.x — a version gate with no read shim — except
- * `configVersion`'s blast radius is the whole CLI rather than one subsystem.
- *
- * This module mirrors the in-tree template for that fix,
- * `src/tasks/source/parse-task-source.ts`'s v2/v3 -> v4 shim: a known-old
- * version routes through a pure, in-memory upgrade function to the current
- * shape, with a one-line stderr deprecation warning; the result is never
- * written back to disk (the on-disk rewrite already happens for free — every
- * `saveConfig`/`mutateConfig` write forces `configVersion` to
- * {@link CURRENT_CONFIG_VERSION}, so the very next `akm config set` or any
- * other mutating command silences the warning permanently). A version that is
- * neither current nor a known old version — including anything NEWER than
- * current — still fails closed with `UNSUPPORTED_CONFIG_VERSION`:
- * forward-incompatibility is a real hazard (an older binary must not guess at
- * a newer, unknown shape) and this shim does not soften that.
- *
- * IMPORTANT — as of this writing, `"0.9.0"` is the only `configVersion` akm
- * has ever shipped; there is no real prior release to shim. `"0.0.1"` below
- * is a SYNTHETIC placeholder entry that exists solely to stand up and
- * exercise this mechanism — the known-versions list, the dispatch table, the
- * warn-once-and-upgrade behavior, the fail-closed behavior for anything
- * else — before a real bump ever needs it (see
- * `tests/integration/config-version-shim.test.ts` and the
- * `previous-release-corpus.test.ts` fixture). When the first genuine
- * `configVersion` bump ships, add its real old shape as its own entry the
- * same way and delete the synthetic `"0.0.1"` entry (and this paragraph) in
- * the same change.
- */
-import { ConfigError } from "../errors.js";
-import { warn } from "../warn.js";
-import { CURRENT_CONFIG_VERSION } from "./schema/primitives.js";
-/**
- * Every `configVersion` this binary can still READ, other than
- * {@link CURRENT_CONFIG_VERSION} itself — each with an in-memory upgrade
- * function in {@link CONFIG_VERSION_UPGRADES}. Anything not in this list (and
- * not equal to current) fails closed.
- */
-export const KNOWN_OLD_CONFIG_VERSIONS = ["0.0.1"];
-function isKnownOldConfigVersion(value) {
-    return typeof value === "string" && KNOWN_OLD_CONFIG_VERSIONS.includes(value);
-}
-/**
- * SYNTHETIC 0.0.1 -> 0.9.0 upgrade (placeholder — see module doc). Per this
- * placeholder, 0.0.1 kept the default LLM engine name at the config root as
- * `defaultEngine`; 0.9.0 moved it under `defaults.llmEngine`. Pure function:
- * takes the raw parsed JSON object, returns a new raw object with the 0.9.0
- * shape. Never touches disk.
- */
-function upgradeFrom080(raw) {
-    const { defaultEngine, defaults, ...rest } = raw;
-    if (typeof defaultEngine !== "string" || defaultEngine.length === 0) {
-        return { ...rest, ...(defaults !== undefined ? { defaults } : {}), configVersion: CURRENT_CONFIG_VERSION };
-    }
-    const existingDefaults = defaults !== null && typeof defaults === "object" ? defaults : {};
-    return {
-        ...rest,
-        configVersion: CURRENT_CONFIG_VERSION,
-        // An explicit `defaults.llmEngine` already present in the raw 0.0.1
-        // document (should never happen for a real 0.0.1 file, but a malformed
-        // one is possible) wins over the root-level field being migrated in.
-        defaults: { llmEngine: defaultEngine, ...existingDefaults },
-    };
-}
-const CONFIG_VERSION_UPGRADES = {
-    "0.0.1": upgradeFrom080,
-};
-function unsupportedConfigVersionError(rawVersion, sourcePath) {
-    const where = sourcePath ? ` at ${sourcePath}` : "";
-    const supported = [CURRENT_CONFIG_VERSION, ...KNOWN_OLD_CONFIG_VERSIONS].map((v) => `"${v}"`).join(", ");
-    return new ConfigError(`Unsupported configVersion${where}: got ${JSON.stringify(rawVersion)}, expected one of ${supported}.`, "UNSUPPORTED_CONFIG_VERSION", "Recreate engines and improve.strategies manually for AKM 0.9.0; profile-based configuration is not translated automatically.");
-}
-/**
- * Route a raw parsed config object through the version shim before schema
- * validation. Returns a raw object whose `configVersion` is
- * {@link CURRENT_CONFIG_VERSION} — either unchanged (already current),
- * in-memory-upgraded (a known old version, with a one-line stderr warning),
- * or this throws `UNSUPPORTED_CONFIG_VERSION` (unknown, newer, missing, or
- * malformed).
- */
-export function upgradeConfigVersion(raw, sourcePath) {
-    const version = raw.configVersion;
-    if (version === CURRENT_CONFIG_VERSION)
-        return raw;
-    if (isKnownOldConfigVersion(version)) {
-        const upgraded = CONFIG_VERSION_UPGRADES[version](raw);
-        warn(`Config${sourcePath ? ` at ${sourcePath}` : ""} uses configVersion "${version}" — auto-upgraded to ${CURRENT_CONFIG_VERSION} in memory; the next config write (e.g. \`akm config set\`) persists this and silences the warning.`);
-        return upgraded;
-    }
-    throw unsupportedConfigVersionError(version, sourcePath);
-}