agentplane 0.3.14 → 0.3.16

package/dist/commands/guard/impl/commands.js

@@ -1,549 +1,4 @@
-import { mkdir, rm, writeFile } from "node:fs/promises";
-import path from "node:path";
-import { extractTaskSuffix } from "@agentplaneorg/core";
-import { resolveTaskIndexPath } from "../../../backends/task-index.js";
-import { mapCoreError } from "../../../cli/error-map.js";
-import { infoMessage, successMessage } from "../../../cli/output.js";
-import { stripAnsi } from "../../../cli/shared/ansi.js";
-import { withDiagnosticContext } from "../../../shared/diagnostics.js";
-import { CliError } from "../../../shared/errors.js";
-import { refreshBranchPrArtifactsAfterTaskCommit } from "../../shared/post-commit-pr-artifacts.js";
-import { isTaskLocalAdvancePath } from "../../shared/task-local-freshness.js";
-import { loadCommandContext } from "../../shared/task-backend.js";
-import { loadTaskFromContext } from "../../shared/task-backend.js";
-import { execFileAsync, gitEnv } from "../../shared/git.js";
-import { ensureReconciledBeforeMutation } from "../../shared/reconcile-check.js";
-import { stageAllowlist, suggestAllowPrefixes } from "./allow.js";
-import { buildCloseCommitMessage, taskReadmePathForTask } from "./close-message.js";
-import { buildGitCommitEnv, resolveCanonicalGitIdentity } from "./env.js";
-import { guardCommitCheck } from "./policy.js";
-const COMMIT_FAILURE_SIGNAL_PATTERNS = [
-    /Code style issues found/i,
-    /Run Prettier with --write/i,
-    /\bESLint\b/i,
-    /\b[0-9]+\s+problems?\b/i,
-    /\berror\b/i,
-    /\bfailed\b/i,
-    /✖/,
-];
-const FORMATTER_SIGNAL_PATTERNS = [
-    /Code style issues found/i,
-    /Run Prettier with --write/i,
-];
-const ESLINT_SIGNAL_PATTERNS = [/\bESLint\b/i, /\b[0-9]+\s+problems?\b/i];
-async function resetRebuildableTaskIndexCache(ctx) {
-    const gitRoot = path.resolve(ctx.resolvedProject.gitRoot);
-    const workflowDirAbs = path.resolve(gitRoot, ctx.config.paths.workflow_dir);
-    const cachePath = path.resolve(resolveTaskIndexPath(workflowDirAbs));
-    const relativeCachePath = path.relative(gitRoot, cachePath);
-    if (!relativeCachePath || relativeCachePath.startsWith(".."))
-        return;
-    try {
-        await execFileAsync("git", ["ls-files", "--error-unmatch", "--", relativeCachePath], {
-            cwd: gitRoot,
-            env: gitEnv(),
-        });
-        const gitPath = relativeCachePath.split(path.sep).join("/");
-        const cacheBlob = await execFileAsync("git", ["show", `HEAD:${gitPath}`], {
-            cwd: gitRoot,
-            env: gitEnv(),
-        });
-        await mkdir(path.dirname(cachePath), { recursive: true });
-        await writeFile(cachePath, cacheBlob.stdout, "utf8");
-        await execFileAsync("git", ["restore", "--staged", "--", relativeCachePath], {
-            cwd: gitRoot,
-            env: gitEnv(),
-        });
-    }
-    catch {
-        // The task index is a rebuildable cache. If it is absent from HEAD here, remove it so
-        // deterministic close commits only see canonical task artifacts.
-        await rm(cachePath, { force: true });
-    }
-    ctx.git.invalidateStatus();
-}
-function readText(value) {
-    if (typeof value === "string")
-        return value;
-    if (Buffer.isBuffer(value))
-        return value.toString("utf8");
-    return "";
-}
-function summarizeOutput(raw) {
-    const lines = raw
-        .replaceAll("\r\n", "\n")
-        .split("\n")
-        .map((line) => stripAnsi(line).trimEnd())
-        .filter((line) => line.trim().length > 0)
-        .map((line) => (line.length > 180 ? `${line.slice(0, 180)} [truncated]` : line));
-    if (lines.length <= 12)
-        return lines;
-    const selected = new Set();
-    for (let index = 0; index < Math.min(6, lines.length); index += 1) {
-        selected.add(index);
-    }
-    for (let index = Math.max(lines.length - 6, 0); index < lines.length; index += 1) {
-        selected.add(index);
-    }
-    for (const [index, line] of lines.entries()) {
-        if (selected.has(index))
-            continue;
-        if (COMMIT_FAILURE_SIGNAL_PATTERNS.some((pattern) => pattern.test(line))) {
-            selected.add(index);
-        }
-    }
-    const ordered = [...selected].toSorted((a, b) => a - b);
-    const summary = [];
-    let previous = -1;
-    for (const index of ordered) {
-        if (previous >= 0 && index - previous > 1) {
-            summary.push(`[${index - previous - 1} lines omitted]`);
-        }
-        summary.push(lines[index] ?? "");
-        previous = index;
-    }
-    return summary;
-}
-function detectCommitFailureSignal(output) {
-    if (FORMATTER_SIGNAL_PATTERNS.some((pattern) => pattern.test(output))) {
-        return "formatter";
-    }
-    if (ESLINT_SIGNAL_PATTERNS.some((pattern) => pattern.test(output))) {
-        return "eslint";
-    }
-    return null;
-}
-function taskArtifactRefreshCommitMessage(taskId) {
-    return `📝 ${extractTaskSuffix(taskId)} task: refresh PR artifacts`;
-}
-async function commitRefreshedTaskArtifacts(opts) {
-    const changedPaths = await opts.ctx.git.statusChangedPaths();
-    const taskArtifactPaths = changedPaths.filter((relPath) => isTaskLocalAdvancePath({
-        workflowDir: opts.ctx.config.paths.workflow_dir,
-        taskId: opts.taskId,
-        tasksPath: opts.ctx.config.paths.tasks_path,
-        relPath,
-    }));
-    if (taskArtifactPaths.length === 0)
-        return false;
-    await stageAllowlist({
-        ctx: opts.ctx,
-        allow: [],
-        allowTasks: true,
-        allowPolicy: false,
-        allowConfig: false,
-        allowHooks: false,
-        allowCI: false,
-        tasksPath: opts.ctx.config.paths.tasks_path,
-        workflowDir: opts.ctx.config.paths.workflow_dir,
-        taskId: opts.taskId,
-        allowTaskOnly: true,
-        emptyAllowMessage: "PR artifact refresh produced no task-local files to stage for the follow-up commit.",
-        noMatchMessage: "PR artifact refresh produced changes outside the active task artifact scope; inspect the working tree before retrying the commit flow.",
-    });
-    const message = taskArtifactRefreshCommitMessage(opts.taskId);
-    await guardCommitCheck({
-        ctx: opts.ctx,
-        cwd: opts.cwd,
-        rootOverride: opts.rootOverride,
-        baseBranchOverride: null,
-        taskId: opts.taskId,
-        message,
-        allow: [],
-        allowBase: false,
-        allowTasks: true,
-        allowPolicy: false,
-        allowConfig: false,
-        allowHooks: false,
-        allowCI: false,
-        requireClean: true,
-        quiet: opts.quiet,
-    });
-    const env = buildGitCommitEnv({
-        taskId: opts.taskId,
-        allowTasks: true,
-        allowBase: false,
-        allowPolicy: false,
-        allowConfig: false,
-        allowHooks: false,
-        allowCI: false,
-        gitIdentity: await resolveCanonicalGitIdentity(),
-    });
-    await opts.ctx.git.commit({ message, env });
-    return true;
-}
-function commitFailureDiagnostic(phase, output) {
-    const signal = detectCommitFailureSignal(output);
-    if (signal === "formatter") {
-        return {
-            state: phase === "close_commit"
-                ? "git rejected the generated close commit"
-                : "git rejected the requested task-scoped commit",
-            likelyCause: phase === "close_commit"
-                ? "a formatting check in the pre-commit path rejected the deterministic close commit after the task README was staged"
-                : "a formatting check in the pre-commit path rejected the staged task-scoped commit",
-            nextAction: {
-                command: "bun run format",
-                reason: "apply formatter fixes before retrying the commit flow",
-                reasonCode: "git_pre_commit_format",
-            },
-        };
-    }
-    if (signal === "eslint") {
-        return {
-            state: phase === "close_commit"
-                ? "git rejected the generated close commit"
-                : "git rejected the requested task-scoped commit",
-            likelyCause: phase === "close_commit"
-                ? "a lint check in the pre-commit path rejected the deterministic close commit after the task README was staged"
-                : "a lint check in the pre-commit path rejected the staged task-scoped commit",
-            nextAction: {
-                command: "bun run lint:core",
-                reason: "rerun lint and fix the reported error before retrying the commit flow",
-                reasonCode: "git_pre_commit_lint",
-            },
-        };
-    }
-    if (phase === "close_commit") {
-        return {
-            state: "git rejected the generated close commit",
-            likelyCause: "a hook or commit policy blocked the deterministic task close commit after the task README was staged",
-            nextAction: {
-                command: "git status --short --untracked-files=no",
-                reason: "inspect the staged close-commit payload before fixing the hook or policy failure",
-                reasonCode: "git_close_commit_blocked",
-            },
-        };
-    }
-    return {
-        state: "git rejected the requested task-scoped commit",
-        likelyCause: "a hook or commit policy blocked the staged changes after guard validation passed",
-        nextAction: {
-            command: "git status --short --untracked-files=no",
-            reason: "inspect the staged task-scoped payload before fixing the hook or policy failure",
-            reasonCode: "git_task_commit_blocked",
-        },
-    };
-}
-function hasExplicitCommitScope(opts) {
-    return (opts.allow.some((prefix) => prefix.trim().length > 0) ||
-        opts.allowTasks ||
-        opts.allowPolicy ||
-        opts.allowConfig ||
-        opts.allowHooks ||
-        opts.allowCI);
-}
-function asCommitFailure(err, phase) {
-    if (err instanceof Error) {
-        const e = err;
-        const cmd = typeof e.cmd === "string" ? e.cmd : "";
-        if (cmd.startsWith("git commit")) {
-            const output = [readText(e.stderr), readText(e.stdout)]
-                .filter((part) => part.length > 0)
-                .join("\n");
-            const summary = summarizeOutput(output);
-            const code = typeof e.code === "number" ? e.code : null;
-            const lines = ["git commit failed (hook or commit policy).", `command: ${cmd}`];
-            if (typeof code === "number") {
-                lines.push(`exit_code: ${code}`);
-            }
-            if (summary.length > 0)
-                lines.push("output_summary:");
-            lines.push(...summary.map((line) => `  ${line}`));
-            return new CliError({
-                exitCode: 5,
-                code: "E_GIT",
-                message: lines.join("\n"),
-                context: withDiagnosticContext({ command: "commit" }, commitFailureDiagnostic(phase, output)),
-            });
-        }
-        return null;
-    }
-    return null;
-}
-export async function cmdGuardClean(opts) {
-    try {
-        const ctx = await loadCommandContext({
-            cwd: opts.cwd,
-            rootOverride: opts.rootOverride ?? null,
-        });
-        const staged = await ctx.git.statusStagedPaths();
-        if (staged.length > 0) {
-            throw new CliError({
-                exitCode: 5,
-                code: "E_GIT",
-                message: "Staged files exist",
-            });
-        }
-        if (!opts.quiet) {
-            process.stdout.write(`${successMessage("index clean", undefined, "no staged files")}\n`);
-        }
-        return 0;
-    }
-    catch (err) {
-        if (err instanceof CliError)
-            throw err;
-        throw mapCoreError(err, { command: "guard clean", root: opts.rootOverride ?? null });
-    }
-}
-export async function cmdGuardSuggestAllow(opts) {
-    try {
-        const ctx = await loadCommandContext({
-            cwd: opts.cwd,
-            rootOverride: opts.rootOverride ?? null,
-        });
-        const staged = await ctx.git.statusStagedPaths();
-        if (staged.length === 0) {
-            throw new CliError({
-                exitCode: 2,
-                code: "E_USAGE",
-                message: "No staged files (git index empty)",
-            });
-        }
-        const prefixes = suggestAllowPrefixes(staged);
-        if (opts.format === "args") {
-            const args = prefixes.map((p) => `--allow ${p}`).join(" ");
-            process.stdout.write(`${args}\n`);
-        }
-        else {
-            for (const prefix of prefixes)
-                process.stdout.write(`${prefix}\n`);
-        }
-        return 0;
-    }
-    catch (err) {
-        throw mapCoreError(err, { command: "guard suggest-allow", root: opts.rootOverride ?? null });
-    }
-}
-export async function cmdGuardCommit(opts) {
-    try {
-        const ctx = opts.ctx ??
-            (await loadCommandContext({ cwd: opts.cwd, rootOverride: opts.rootOverride ?? null }));
-        await ensureReconciledBeforeMutation({ ctx, command: "guard commit" });
-        await guardCommitCheck({ ...opts, ctx });
-        if (!opts.quiet)
-            process.stdout.write("OK\n");
-        return 0;
-    }
-    catch (err) {
-        if (err instanceof CliError)
-            throw err;
-        throw mapCoreError(err, { command: "guard commit", root: opts.rootOverride ?? null });
-    }
-}
-export async function cmdCommit(opts) {
-    try {
-        const ctx = opts.ctx ??
-            (await loadCommandContext({ cwd: opts.cwd, rootOverride: opts.rootOverride ?? null }));
-        if (opts.close) {
-            if (!opts.closeCheckOnly) {
-                await ensureReconciledBeforeMutation({ ctx, command: "commit" });
-                await resetRebuildableTaskIndexCache(ctx);
-            }
-            // Make the close commit deterministic: start from a clean index unless --unstage-others is used.
-            let staged = await ctx.git.statusStagedPaths();
-            if (staged.length > 0 && opts.closeUnstageOthers) {
-                if (!opts.closeCheckOnly) {
-                    await execFileAsync("git", ["restore", "--staged", "--", "."], {
-                        cwd: ctx.resolvedProject.gitRoot,
-                        env: gitEnv(),
-                    });
-                }
-                staged = opts.closeCheckOnly ? staged : await ctx.git.statusStagedPaths();
-            }
-            if (staged.length > 0 && !opts.closeUnstageOthers) {
-                throw new CliError({
-                    exitCode: 5,
-                    code: "E_GIT",
-                    message: "Staged files exist (close commit requires an empty index; rerun with --unstage-others to auto-unstage).",
-                    context: withDiagnosticContext({ command: "commit" }, {
-                        state: "close commit cannot run with a non-empty git index",
-                        likelyCause: "deterministic close commits only stage the active task artifact scope, but other staged files are already in the index",
-                        nextAction: {
-                            command: "git restore --staged -- .",
-                            reason: "clear the current index before rerunning the close commit flow",
-                            reasonCode: "git_close_commit_dirty_index",
-                        },
-                    }),
-                });
-            }
-            const task = await loadTaskFromContext({ ctx, taskId: opts.taskId });
-            const msg = await buildCloseCommitMessage({ gitRoot: ctx.resolvedProject.gitRoot, task });
-            const readmeAbs = taskReadmePathForTask({
-                gitRoot: ctx.resolvedProject.gitRoot,
-                workflowDir: ctx.config.paths.workflow_dir,
-                taskId: opts.taskId,
-            });
-            const readmeRel = readmeAbs.startsWith(ctx.resolvedProject.gitRoot)
-                ? readmeAbs.slice(ctx.resolvedProject.gitRoot.length + 1)
-                : readmeAbs;
-            if (opts.closeCheckOnly) {
-                if (!opts.quiet) {
-                    const stagedCount = staged.length;
-                    const suffix = stagedCount > 0 && opts.closeUnstageOthers
-                        ? `; would unstage ${stagedCount} path(s)`
-                        : "";
-                    process.stdout.write(`${successMessage("close preflight", opts.taskId, `subject=${msg.subject}${suffix}`)}\n`);
-                }
-                return 0;
-            }
-            if (opts.closeStageTaskArtifacts === true) {
-                if (opts.closeRefreshTaskArtifacts !== false) {
-                    await refreshBranchPrArtifactsAfterTaskCommit({
-                        ctx,
-                        cwd: opts.cwd,
-                        rootOverride: opts.rootOverride,
-                        taskId: opts.taskId,
-                        quiet: opts.quiet,
-                    });
-                }
-                // Artifact refresh writes tracked task files on disk; invalidate the memoized
-                // porcelain snapshot so staging/cleanliness checks see the current task artifact state.
-                ctx.git.invalidateStatus();
-            }
-            await (opts.closeStageTaskArtifacts === true
-                ? stageAllowlist({
-                    ctx,
-                    allow: [],
-                    allowTasks: true,
-                    allowPolicy: opts.allowPolicy,
-                    tasksPath: ctx.config.paths.tasks_path,
-                    workflowDir: ctx.config.paths.workflow_dir,
-                    taskId: opts.taskId,
-                    allowTaskOnly: true,
-                    emptyAllowMessage: "No changed task artifacts to stage for the deterministic close commit.",
-                    noMatchMessage: "No changed files matched the active task artifact scope for the deterministic close commit.",
-                })
-                : ctx.git.stage([readmeRel]));
-            // Close commits should not require manual --allow flags:
-            // the command stages only the active task artifact scope.
-            await guardCommitCheck({
-                ctx,
-                cwd: opts.cwd,
-                rootOverride: opts.rootOverride,
-                baseBranchOverride: opts.baseBranchOverride ?? null,
-                taskId: opts.taskId,
-                message: msg.subject,
-                allow: [],
-                allowBase: opts.allowBase,
-                allowTasks: true,
-                allowPolicy: opts.allowPolicy,
-                allowConfig: false,
-                allowHooks: false,
-                allowCI: false,
-                requireClean: true,
-                quiet: opts.quiet,
-            });
-            const env = buildGitCommitEnv({
-                taskId: opts.taskId,
-                allowTasks: true,
-                allowBase: opts.allowBase,
-                allowPolicy: opts.allowPolicy,
-                allowConfig: false,
-                allowHooks: false,
-                allowCI: false,
-                allowStaleDist: true,
-                gitIdentity: await resolveCanonicalGitIdentity(),
-            });
-            await ctx.git.commit({ message: msg.subject, body: msg.body, env });
-            if (!opts.quiet) {
-                const { hash, subject } = await ctx.git.headHashSubject();
-                process.stdout.write(`${successMessage("committed", `${hash?.slice(0, 12) ?? ""} ${subject ?? ""}`.trim())}\n`);
-            }
-            return 0;
-        }
-        if (opts.autoAllow) {
-            throw new CliError({
-                exitCode: 2,
-                code: "E_USAGE",
-                message: "--auto-allow is disabled; pass explicit --allow <path-prefix>.",
-            });
-        }
-        await ensureReconciledBeforeMutation({ ctx, command: "commit" });
-        let autoStaged = [];
-        const staged = await ctx.git.statusStagedPaths();
-        if (staged.length === 0) {
-            if (!hasExplicitCommitScope(opts)) {
-                throw new CliError({
-                    exitCode: 2,
-                    code: "E_USAGE",
-                    message: "No staged files and no commit allowlist. Pass --allow <path-prefix>, use --allow-tasks for active task artifacts, or stage files manually.",
-                });
-            }
-            autoStaged = await stageAllowlist({
-                ctx,
-                allow: opts.allow,
-                allowTasks: opts.allowTasks,
-                allowPolicy: opts.allowPolicy,
-                allowConfig: opts.allowConfig,
-                allowHooks: opts.allowHooks,
-                allowCI: opts.allowCI,
-                tasksPath: ctx.config.paths.tasks_path,
-                workflowDir: ctx.config.paths.workflow_dir,
-                taskId: opts.taskId,
-                allowTaskOnly: true,
-                emptyAllowMessage: "No staged files and no commit allowlist. Pass --allow <path-prefix>, use --allow-tasks for active task artifacts, or stage files manually.",
-                noMatchMessage: "No changed files matched the commit allowlist (adjust --allow, protected allow flags, or --allow-tasks; otherwise stage files manually).",
-            });
-            if (!opts.quiet) {
-                process.stdout.write(`${infoMessage(`commit auto-staged ${autoStaged.length} path(s) from allowlist`)}\n`);
-            }
-        }
-        await guardCommitCheck({
-            ctx,
-            cwd: opts.cwd,
-            rootOverride: opts.rootOverride,
-            baseBranchOverride: opts.baseBranchOverride ?? null,
-            taskId: opts.taskId,
-            message: opts.message,
-            allow: opts.allow,
-            allowBase: opts.allowBase,
-            allowTasks: opts.allowTasks,
-            allowPolicy: opts.allowPolicy,
-            allowConfig: opts.allowConfig,
-            allowHooks: opts.allowHooks,
-            allowCI: opts.allowCI,
-            requireClean: opts.requireClean,
-            quiet: opts.quiet,
-        });
-        const env = buildGitCommitEnv({
-            taskId: opts.taskId,
-            allowTasks: opts.allowTasks,
-            allowBase: opts.allowBase,
-            allowPolicy: opts.allowPolicy,
-            allowConfig: opts.allowConfig,
-            allowHooks: opts.allowHooks,
-            allowCI: opts.allowCI,
-            gitIdentity: await resolveCanonicalGitIdentity(),
-        });
-        await ctx.git.commit({ message: opts.message, env });
-        await refreshBranchPrArtifactsAfterTaskCommit({
-            ctx,
-            cwd: opts.cwd,
-            rootOverride: opts.rootOverride,
-            taskId: opts.taskId,
-            quiet: opts.quiet,
-        });
-        ctx.git.invalidateStatus();
-        await commitRefreshedTaskArtifacts({
-            ctx,
-            cwd: opts.cwd,
-            rootOverride: opts.rootOverride,
-            taskId: opts.taskId,
-            quiet: opts.quiet,
-        });
-        if (!opts.quiet) {
-            const { hash, subject } = await ctx.git.headHashSubject();
-            process.stdout.write(`${successMessage("committed", `${hash?.slice(0, 12) ?? ""} ${subject ?? ""}`.trim(), autoStaged.length > 0 ? `staged=${autoStaged.join(", ")}` : undefined)}\n`);
-        }
-        return 0;
-    }
-    catch (err) {
-        if (err instanceof CliError)
-            throw err;
-        const commitFailure = asCommitFailure(err, opts.close ? "close_commit" : "task_commit");
-        if (commitFailure)
-            throw commitFailure;
-        throw mapCoreError(err, { command: "commit", root: opts.rootOverride ?? null });
-    }
-}
+export { cmdCommit } from "./commit.js";
+export { cmdGuardClean } from "./clean.js";
+export { cmdGuardCommit } from "./guard-commit.js";
+export { cmdGuardSuggestAllow } from "./suggest.js";

package/dist/commands/guard/impl/comment-commit.js

@@ -1,7 +1,7 @@
 import { extractTaskSuffix } from "@agentplaneorg/core";
 import { invalidValueMessage, successMessage } from "../../../cli/output.js";
 import { CliError } from "../../../shared/errors.js";
-import { formatCommentBodyForCommit, normalizeCommentBodyForCommit, } from "../../../shared/comment-format.js";
+import { formatCommentBodyForCommit, normalizeCommentBodyForCommit, } from "../../shared/comment-format.js";
 import { loadCommandContext } from "../../shared/task-backend.js";
 import { buildGitCommitEnv, resolveCanonicalGitIdentity } from "./env.js";
 import { stageAllowlist } from "./allow.js";

package/dist/commands/guard/impl/commit-diagnostics.d.ts

@@ -0,0 +1,4 @@
+import { CliError } from "../../../shared/errors.js";
+export type CommitFailurePhase = "task_commit" | "close_commit";
+export declare function asCommitFailure(err: unknown, phase: CommitFailurePhase): CliError | null;
+//# sourceMappingURL=commit-diagnostics.d.ts.map

package/dist/commands/guard/impl/commit-diagnostics.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"commit-diagnostics.d.ts","sourceRoot":"","sources":["../../../../src/commands/guard/impl/commit-diagnostics.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,QAAQ,EAAE,MAAM,2BAA2B,CAAC;AAWrD,MAAM,MAAM,kBAAkB,GAAG,aAAa,GAAG,cAAc,CAAC;AAwIhE,wBAAgB,eAAe,CAAC,GAAG,EAAE,OAAO,EAAE,KAAK,EAAE,kBAAkB,GAAG,QAAQ,GAAG,IAAI,CAgCxF"}