agentplane 0.3.10 → 0.3.11

package/dist/commands/pr/check.js

@@ -6,12 +6,12 @@ import { fileExists } from "../../cli/fs-utils.js";
 import { createCliEmitter, workflowModeMessage } from "../../cli/output.js";
 import { CliError } from "../../shared/errors.js";
 import { parsePrMeta } from "../shared/pr-meta.js";
-import { gitListTaskBranches, parseTaskIdFromBranch } from "../shared/git-worktree.js";
+import { findWorktreeForBranch, gitListTaskBranches, parseTaskIdFromBranch, } from "../shared/git-worktree.js";
 import { gitRevParse } from "../shared/git-ops.js";
-import { isTaskLocalOnlyAdvance } from "../shared/task-local-freshness.js";
 import { loadBackendTask, loadCommandContext, } from "../shared/task-backend.js";
-import { readPrArtifact, resolvePrPaths } from "./internal/pr-paths.js";
+import { readPrArtifactFromBranch, resolvePrPaths } from "./internal/pr-paths.js";
 import { validateGithubPrBodyContents, validateReviewContents, } from "./internal/review-template.js";
+import { assessPrArtifactFreshness } from "./internal/freshness.js";
 function isUnknownRevisionError(err) {
     const message = err instanceof Error ? err.message : String(err);
     return /unknown revision or path not in the working tree/i.test(message);
@@ -31,26 +31,101 @@ async function resolveArtifactBranch(opts) {
     }
     return null;
 }
-async function readPrArtifactWithOptionalBranch(opts) {
-    const localPath = path.join(opts.prDir, opts.fileName);
-    if (await fileExists(localPath)) {
-        return await readFile(localPath, "utf8");
+async function readLocalPrArtifactText(prDir, fileName) {
+    const localPath = path.join(prDir, fileName);
+    if (!(await fileExists(localPath)))
+        return null;
+    return await readFile(localPath, "utf8");
+}
+function validateSnapshotContents(opts) {
+    const errors = [];
+    let meta = null;
+    if (opts.texts.metaText) {
+        try {
+            meta = parsePrMeta(opts.texts.metaText, opts.taskId);
+        }
+        catch (err) {
+            const message = err instanceof Error ? err.message : String(err);
+            errors.push(message);
+        }
     }
-    if (opts.branchCache.value === undefined) {
-        opts.branchCache.value = await resolveArtifactBranch({
-            ctx: opts.ctx,
-            resolved: opts.resolved,
-            taskId: opts.taskId,
-        });
+    else {
+        errors.push(`Missing PR directory: ${opts.relPrDir}`, `Missing ${opts.relMetaPath}`);
     }
-    if (!opts.branchCache.value)
-        return null;
-    return await readPrArtifact({
-        resolved: opts.resolved,
-        prDir: opts.prDir,
-        fileName: opts.fileName,
-        branch: opts.branchCache.value,
+    if (opts.texts.diffstatText === null)
+        errors.push(`Missing ${opts.relDiffstatPath}`);
+    if (opts.texts.verifyLogText === null)
+        errors.push(`Missing ${opts.relVerifyLogPath}`);
+    if (opts.texts.reviewText) {
+        validateReviewContents(opts.texts.reviewText, errors);
+    }
+    else {
+        errors.push(`Missing ${opts.relReviewPath}`);
+    }
+    if (!opts.texts.githubTitleText?.trim()) {
+        errors.push(`Missing ${opts.relGithubTitlePath}`);
+    }
+    if (opts.texts.githubBodyText) {
+        validateGithubPrBodyContents(opts.texts.githubBodyText, errors);
+    }
+    else {
+        errors.push(`Missing ${opts.relGithubBodyPath}`);
+    }
+    return { meta, errors };
+}
+async function evaluateSnapshotFreshness(opts) {
+    if (!opts.snapshot.meta || !opts.branchHeadSha)
+        return;
+    const freshness = await assessPrArtifactFreshness({
+        gitRoot: opts.gitRoot,
+        workflowDir: opts.workflowDir,
+        taskId: opts.taskId,
+        branchHeadSha: opts.branchHeadSha,
+        metaHeadSha: opts.snapshot.meta.head_sha ?? null,
+        metaLastVerifiedSha: opts.snapshot.meta.last_verified_sha ?? null,
+        metaVerifyStatus: opts.snapshot.meta.verify?.status ?? null,
+        taskVerificationState: opts.taskVerificationState,
+        verifyLogText: opts.snapshot.texts.verifyLogText,
+        requiresVerify: opts.requiresVerify,
     });
+    opts.snapshot.freshnessEvaluated = true;
+    opts.snapshot.freshnessReviewFresh = freshness.reviewFresh;
+    opts.snapshot.freshnessVerifySatisfied = freshness.verifySatisfied;
+    opts.snapshot.freshnessVerifyFresh = freshness.verifyFresh;
+    opts.snapshot.freshnessVerifyLogSha = freshness.verifyLogSha;
+}
+function finalizeSnapshotErrors(opts) {
+    const errors = [...opts.snapshot.errors];
+    const meta = opts.snapshot.meta;
+    if (!meta)
+        return errors;
+    if (opts.branchHeadSha && opts.snapshot.freshnessEvaluated) {
+        if (!opts.snapshot.freshnessReviewFresh) {
+            errors.push(`PR artifacts stale: head_sha=${meta.head_sha ?? "<missing>"} current_head=${opts.branchHeadSha}`);
+        }
+        if (opts.requiresVerify && !opts.snapshot.freshnessVerifySatisfied) {
+            if (meta.verify?.status !== "pass") {
+                errors.push("Verify requirements not satisfied (meta.verify.status != pass)");
+            }
+            if ((!meta.last_verified_sha || !meta.last_verified_at) &&
+                !opts.snapshot.freshnessVerifyLogSha) {
+                errors.push("Verify metadata missing (last_verified_sha/last_verified_at)");
+            }
+        }
+        if (opts.requiresVerify && meta.last_verified_sha && !opts.snapshot.freshnessVerifyFresh) {
+            errors.push(`Verify state stale: last_verified_sha=${meta.last_verified_sha} current_head=${opts.branchHeadSha}`);
+        }
+        return errors;
+    }
+    if (opts.requiresVerify) {
+        if (meta.verify?.status !== "pass") {
+            errors.push("Verify requirements not satisfied (meta.verify.status != pass)");
+        }
+        if (!meta.last_verified_sha || !meta.last_verified_at) {
+            errors.push("Verify metadata missing (last_verified_sha/last_verified_at)");
+        }
+    }
+    return errors;
 }
 export async function cmdPrCheck(opts) {
     try {
@@ -80,99 +155,51 @@ export async function cmdPrCheck(opts) {
         const relGithubTitlePath = path.relative(resolved.gitRoot, githubTitlePath);
         const relGithubBodyPath = path.relative(resolved.gitRoot, githubBodyPath);
         const branchCache = {};
-        let meta = null;
-        const metaText = await readPrArtifactWithOptionalBranch({
-            ctx,
-            resolved,
-            prDir,
-            fileName: "meta.json",
+        const requiresVerify = Boolean(task.verify && task.verify.length > 0);
+        const localTexts = {
+            metaText: await readLocalPrArtifactText(prDir, "meta.json"),
+            diffstatText: await readLocalPrArtifactText(prDir, "diffstat.txt"),
+            verifyLogText: await readLocalPrArtifactText(prDir, "verify.log"),
+            reviewText: await readLocalPrArtifactText(prDir, "review.md"),
+            githubTitleText: await readLocalPrArtifactText(prDir, "github-title.txt"),
+            githubBodyText: await readLocalPrArtifactText(prDir, "github-body.md"),
+        };
+        const localParsed = validateSnapshotContents({
+            texts: localTexts,
+            relPrDir,
+            relMetaPath,
+            relDiffstatPath,
+            relVerifyLogPath,
+            relReviewPath,
+            relGithubTitlePath,
+            relGithubBodyPath,
             taskId: task.id,
-            branchCache,
         });
-        if (metaText) {
-            try {
-                meta = parsePrMeta(metaText, task.id);
-            }
-            catch (err) {
-                const message = err instanceof Error ? err.message : String(err);
-                errors.push(message);
-            }
+        const localSnapshot = {
+            source: "local",
+            texts: localTexts,
+            meta: localParsed.meta,
+            errors: localParsed.errors,
+            freshnessEvaluated: false,
+            freshnessReviewFresh: false,
+            freshnessVerifySatisfied: false,
+            freshnessVerifyFresh: false,
+            freshnessVerifyLogSha: null,
+        };
+        const localBranch = localSnapshot.meta?.branch?.trim() ?? "";
+        if (localBranch) {
+            branchCache.value = localBranch;
         }
-        else {
-            errors.push(`Missing PR directory: ${relPrDir}`, `Missing ${relMetaPath}`);
-        }
-        const diffstatText = await readPrArtifactWithOptionalBranch({
-            ctx,
-            resolved,
-            prDir,
-            fileName: "diffstat.txt",
-            taskId: task.id,
-            branchCache,
-        });
-        if (diffstatText === null) {
-            errors.push(`Missing ${relDiffstatPath}`);
-        }
-        const verifyLogText = await readPrArtifactWithOptionalBranch({
-            ctx,
-            resolved,
-            prDir,
-            fileName: "verify.log",
-            taskId: task.id,
-            branchCache,
-        });
-        if (verifyLogText === null) {
-            errors.push(`Missing ${relVerifyLogPath}`);
-        }
-        const reviewText = await readPrArtifactWithOptionalBranch({
-            ctx,
-            resolved,
-            prDir,
-            fileName: "review.md",
-            taskId: task.id,
-            branchCache,
-        });
-        if (reviewText) {
-            validateReviewContents(reviewText, errors);
-        }
-        else {
-            errors.push(`Missing ${relReviewPath}`);
-        }
-        const githubTitleText = await readPrArtifactWithOptionalBranch({
-            ctx,
-            resolved,
-            prDir,
-            fileName: "github-title.txt",
-            taskId: task.id,
-            branchCache,
-        });
-        if (!githubTitleText?.trim()) {
-            errors.push(`Missing ${relGithubTitlePath}`);
-        }
-        const githubBodyText = await readPrArtifactWithOptionalBranch({
-            ctx,
-            resolved,
-            prDir,
-            fileName: "github-body.md",
-            taskId: task.id,
-            branchCache,
-        });
-        if (githubBodyText) {
-            validateGithubPrBodyContents(githubBodyText, errors);
-        }
-        else {
-            errors.push(`Missing ${relGithubBodyPath}`);
-        }
-        if (task.verify && task.verify.length > 0) {
-            if (meta?.verify?.status !== "pass") {
-                errors.push("Verify requirements not satisfied (meta.verify.status != pass)");
-            }
-            if (!meta?.last_verified_sha || !meta.last_verified_at) {
-                errors.push("Verify metadata missing (last_verified_sha/last_verified_at)");
-            }
+        else if (branchCache.value === undefined) {
+            branchCache.value = await resolveArtifactBranch({
+                ctx,
+                resolved,
+                taskId: task.id,
+            });
         }
-        const branchForFreshness = branchCache.value ?? (typeof meta?.branch === "string" ? meta.branch.trim() : null);
-        if (meta && branchForFreshness) {
-            let branchHeadSha = null;
+        const branchForFreshness = branchCache.value ?? null;
+        let branchHeadSha = null;
+        if (branchForFreshness) {
             try {
                 branchHeadSha = await gitRevParse(resolved.gitRoot, [branchForFreshness]);
             }
@@ -180,34 +207,110 @@ export async function cmdPrCheck(opts) {
                 if (!isUnknownRevisionError(err))
                     throw err;
             }
-            if (branchHeadSha) {
-                const reviewFresh = (meta.head_sha ?? null) === branchHeadSha ||
-                    (await isTaskLocalOnlyAdvance({
-                        gitRoot: resolved.gitRoot,
-                        workflowDir: config.paths.workflow_dir,
-                        taskId: task.id,
-                        fromRef: meta.head_sha ?? null,
-                        toRef: branchHeadSha,
-                    }));
-                if (!reviewFresh) {
-                    errors.push(`PR artifacts stale: head_sha=${meta.head_sha ?? "<missing>"} current_head=${branchHeadSha}`);
-                }
-                const verifyFresh = !task.verify ||
-                    task.verify.length === 0 ||
-                    !meta.last_verified_sha ||
-                    meta.last_verified_sha === branchHeadSha ||
-                    (await isTaskLocalOnlyAdvance({
-                        gitRoot: resolved.gitRoot,
-                        workflowDir: config.paths.workflow_dir,
-                        taskId: task.id,
-                        fromRef: meta.last_verified_sha,
-                        toRef: branchHeadSha,
-                    }));
-                if (task.verify && task.verify.length > 0 && meta.last_verified_sha && !verifyFresh) {
-                    errors.push(`Verify state stale: last_verified_sha=${meta.last_verified_sha} current_head=${branchHeadSha}`);
-                }
+        }
+        await evaluateSnapshotFreshness({
+            snapshot: localSnapshot,
+            gitRoot: resolved.gitRoot,
+            workflowDir: config.paths.workflow_dir,
+            taskId: task.id,
+            branchHeadSha,
+            taskVerificationState: task.verification?.state ?? null,
+            requiresVerify,
+        });
+        let selectedSnapshot = localSnapshot;
+        if (branchForFreshness &&
+            branchHeadSha &&
+            (!localSnapshot.meta ||
+                !localSnapshot.freshnessReviewFresh ||
+                (requiresVerify && !localSnapshot.freshnessVerifySatisfied))) {
+            const worktreePath = await findWorktreeForBranch(resolved.gitRoot, branchForFreshness);
+            const branchTexts = {
+                metaText: await readPrArtifactFromBranch({
+                    resolved,
+                    prDir,
+                    fileName: "meta.json",
+                    branch: branchForFreshness,
+                    worktreePath,
+                }),
+                diffstatText: await readPrArtifactFromBranch({
+                    resolved,
+                    prDir,
+                    fileName: "diffstat.txt",
+                    branch: branchForFreshness,
+                    worktreePath,
+                }),
+                verifyLogText: await readPrArtifactFromBranch({
+                    resolved,
+                    prDir,
+                    fileName: "verify.log",
+                    branch: branchForFreshness,
+                    worktreePath,
+                }),
+                reviewText: await readPrArtifactFromBranch({
+                    resolved,
+                    prDir,
+                    fileName: "review.md",
+                    branch: branchForFreshness,
+                    worktreePath,
+                }),
+                githubTitleText: await readPrArtifactFromBranch({
+                    resolved,
+                    prDir,
+                    fileName: "github-title.txt",
+                    branch: branchForFreshness,
+                    worktreePath,
+                }),
+                githubBodyText: await readPrArtifactFromBranch({
+                    resolved,
+                    prDir,
+                    fileName: "github-body.md",
+                    branch: branchForFreshness,
+                    worktreePath,
+                }),
+            };
+            const branchParsed = validateSnapshotContents({
+                texts: branchTexts,
+                relPrDir,
+                relMetaPath,
+                relDiffstatPath,
+                relVerifyLogPath,
+                relReviewPath,
+                relGithubTitlePath,
+                relGithubBodyPath,
+                taskId: task.id,
+            });
+            const branchSnapshot = {
+                source: "branch",
+                texts: branchTexts,
+                meta: branchParsed.meta,
+                errors: branchParsed.errors,
+                freshnessEvaluated: false,
+                freshnessReviewFresh: false,
+                freshnessVerifySatisfied: false,
+                freshnessVerifyFresh: false,
+                freshnessVerifyLogSha: null,
+            };
+            await evaluateSnapshotFreshness({
+                snapshot: branchSnapshot,
+                gitRoot: resolved.gitRoot,
+                workflowDir: config.paths.workflow_dir,
+                taskId: task.id,
+                branchHeadSha,
+                taskVerificationState: task.verification?.state ?? null,
+                requiresVerify,
+            });
+            if (branchSnapshot.errors.length === 0 &&
+                branchSnapshot.meta &&
+                branchSnapshot.freshnessReviewFresh &&
+                (!requiresVerify || branchSnapshot.freshnessVerifySatisfied)) {
+                selectedSnapshot = branchSnapshot;
             }
         }
+        errors.push(...finalizeSnapshotErrors({
+            snapshot: selectedSnapshot,
+            branchHeadSha,
+            requiresVerify,
+        }));
         if (errors.length > 0) {
             throw new CliError({
                 exitCode: exitCodeForError("E_VALIDATION"),

package/dist/commands/pr/close-superseded.d.ts

@@ -0,0 +1,9 @@
+import { type CommandContext } from "../shared/task-backend.js";
+export declare function cmdPrCloseSuperseded(opts: {
+    ctx?: CommandContext;
+    cwd: string;
+    rootOverride?: string;
+    taskId: string;
+    deleteRemoteBranch: boolean;
+}): Promise<number>;
+//# sourceMappingURL=close-superseded.d.ts.map

package/dist/commands/pr/close-superseded.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"close-superseded.d.ts","sourceRoot":"","sources":["../../../src/commands/pr/close-superseded.ts"],"names":[],"mappings":"AAOA,OAAO,EAGL,KAAK,cAAc,EACpB,MAAM,2BAA2B,CAAC;AAiCnC,wBAAsB,oBAAoB,CAAC,IAAI,EAAE;IAC/C,GAAG,CAAC,EAAE,cAAc,CAAC;IACrB,GAAG,EAAE,MAAM,CAAC;IACZ,YAAY,CAAC,EAAE,MAAM,CAAC;IACtB,MAAM,EAAE,MAAM,CAAC;IACf,kBAAkB,EAAE,OAAO,CAAC;CAC7B,GAAG,OAAO,CAAC,MAAM,CAAC,CAsHlB"}

package/dist/commands/pr/close-superseded.js

@@ -0,0 +1,129 @@
+import { readFile } from "node:fs/promises";
+import { mapCoreError } from "../../cli/error-map.js";
+import { exitCodeForError } from "../../cli/exit-codes.js";
+import { createCliEmitter, infoMessage, workflowModeMessage } from "../../cli/output.js";
+import { fileExists } from "../../cli/fs-utils.js";
+import { CliError } from "../../shared/errors.js";
+import { loadBackendTask, loadCommandContext, } from "../shared/task-backend.js";
+import { parsePrMetaForwardCompatible } from "../shared/pr-meta.js";
+import { cmdPrClose } from "./close.js";
+import { isGhNotFound, resolveDefaultGithubRepo, runGhApiJson, runGhApiNoOutput, } from "./internal/gh-api.js";
+import { resolvePrPaths } from "./internal/pr-paths.js";
+async function deleteRemoteBranch(opts) {
+    const endpoint = `repos/${opts.repo}/git/refs/heads/${encodeURIComponent(opts.branch)}`;
+    try {
+        await runGhApiNoOutput(opts.cwd, [endpoint, "-X", "DELETE"]);
+        return "deleted";
+    }
+    catch (err) {
+        if (isGhNotFound(err))
+            return "already-absent";
+        throw err;
+    }
+}
+export async function cmdPrCloseSuperseded(opts) {
+    try {
+        const output = createCliEmitter();
+        const ctx = opts.ctx ??
+            (await loadCommandContext({ cwd: opts.cwd, rootOverride: opts.rootOverride ?? null }));
+        const { task } = await loadBackendTask({
+            ctx,
+            cwd: opts.cwd,
+            rootOverride: opts.rootOverride,
+            taskId: opts.taskId,
+        });
+        if (String(task.status ?? "")
+            .trim()
+            .toUpperCase() !== "DONE") {
+            throw new CliError({
+                exitCode: exitCodeForError("E_VALIDATION"),
+                code: "E_VALIDATION",
+                message: `Task ${opts.taskId} must be DONE before closing superseded PRs.`,
+            });
+        }
+        const { config, metaPath, resolved } = await resolvePrPaths({ ...opts, ctx });
+        if (config.workflow_mode !== "branch_pr") {
+            throw new CliError({
+                exitCode: exitCodeForError("E_USAGE"),
+                code: "E_USAGE",
+                message: workflowModeMessage(config.workflow_mode, "branch_pr"),
+            });
+        }
+        if (!(await fileExists(metaPath))) {
+            throw new CliError({
+                exitCode: exitCodeForError("E_VALIDATION"),
+                code: "E_VALIDATION",
+                message: `Missing PR metadata: ${metaPath}`,
+            });
+        }
+        const meta = parsePrMetaForwardCompatible(await readFile(metaPath, "utf8"), opts.taskId);
+        const branch = meta.branch?.trim() ?? "";
+        if (!branch) {
+            throw new CliError({
+                exitCode: exitCodeForError("E_VALIDATION"),
+                code: "E_VALIDATION",
+                message: `Missing PR branch for ${opts.taskId}`,
+            });
+        }
+        const repo = await resolveDefaultGithubRepo(resolved.gitRoot);
+        const owner = repo.split("/", 1)[0]?.trim() ?? "";
+        if (!owner) {
+            throw new CliError({
+                exitCode: exitCodeForError("E_VALIDATION"),
+                code: "E_VALIDATION",
+                message: "Could not derive GitHub owner from remote origin.",
+            });
+        }
+        const openPrs = await runGhApiJson(resolved.gitRoot, [
+            `repos/${repo}/pulls?head=${encodeURIComponent(`${owner}:${branch}`)}&state=open&per_page=100`,
+        ]);
+        if (openPrs.length === 0) {
+            const remoteBranchAction = opts.deleteRemoteBranch
+                ? await deleteRemoteBranch({ cwd: resolved.gitRoot, repo, branch })
+                : "skipped";
+            output.report([
+                { label: "task", value: opts.taskId },
+                { label: "branch", value: branch },
+                { label: "state", value: "skipped" },
+                { label: "reason", value: "no open task PR found" },
+                { label: "remote_branch_action", value: remoteBranchAction },
+            ], { header: infoMessage(`pr close-superseded ${opts.taskId}`) });
+            return 0;
+        }
+        if (openPrs.length > 1) {
+            throw new CliError({
+                exitCode: exitCodeForError("E_VALIDATION"),
+                code: "E_VALIDATION",
+                message: `Multiple open PRs match task ${opts.taskId} branch ${branch}: ${openPrs
+                    .map((pr) => pr.number)
+                    .filter((value) => typeof value === "number" && Number.isInteger(value) && value > 0)
+                    .map((value) => `#${value}`)
+                    .join(", ")}`,
+            });
+        }
+        const prNumber = Number(openPrs[0]?.number ?? 0);
+        if (!Number.isInteger(prNumber) || prNumber <= 0) {
+            throw new CliError({
+                exitCode: exitCodeForError("E_VALIDATION"),
+                code: "E_VALIDATION",
+                message: `Could not determine open PR number for task ${opts.taskId}.`,
+            });
+        }
+        return await cmdPrClose({
+            ctx,
+            cwd: opts.cwd,
+            rootOverride: opts.rootOverride,
+            prNumber,
+            comment: `Superseded by protected-main closure of task ${opts.taskId}.`,
+            deleteRemoteBranch: opts.deleteRemoteBranch,
+        });
+    }
+    catch (err) {
+        if (err instanceof CliError)
+            throw err;
+        throw mapCoreError(err, {
+            command: "pr close-superseded",
+            root: opts.rootOverride ?? null,
+        });
+    }
+}

package/dist/commands/pr/close.d.ts

@@ -0,0 +1,11 @@
+import { type CommandContext } from "../shared/task-backend.js";
+export declare function cmdPrClose(opts: {
+    ctx?: CommandContext;
+    cwd: string;
+    rootOverride?: string;
+    prNumber: number;
+    repo?: string;
+    comment?: string;
+    deleteRemoteBranch: boolean;
+}): Promise<number>;
+//# sourceMappingURL=close.d.ts.map

package/dist/commands/pr/close.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"close.d.ts","sourceRoot":"","sources":["../../../src/commands/pr/close.ts"],"names":[],"mappings":"AAIA,OAAO,EAAsB,KAAK,cAAc,EAAE,MAAM,2BAA2B,CAAC;AA+CpF,wBAAsB,UAAU,CAAC,IAAI,EAAE;IACrC,GAAG,CAAC,EAAE,cAAc,CAAC;IACrB,GAAG,EAAE,MAAM,CAAC;IACZ,YAAY,CAAC,EAAE,MAAM,CAAC;IACtB,QAAQ,EAAE,MAAM,CAAC;IACjB,IAAI,CAAC,EAAE,MAAM,CAAC;IACd,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,kBAAkB,EAAE,OAAO,CAAC;CAC7B,GAAG,OAAO,CAAC,MAAM,CAAC,CAuGlB"}