akm-cli 0.9.16 → 0.9.17-alpha.10

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);
-}