agentplane 0.3.24 → 0.3.27

package/dist/commands/pr/integrate/artifacts.js

@@ -1,115 +0,0 @@
-import path from "node:path";
-import { exitCodeForError } from "../../../cli/exit-codes.js";
-import { CliError } from "../../../shared/errors.js";
-import { readPrArtifact, readPrArtifactFromBranch } from "../internal/pr-paths.js";
-import { findWorktreeForBranch } from "@agentplaneorg/core/git";
-import { validateReviewContents } from "../internal/review-template.js";
-export async function readAndValidatePrArtifacts(opts) {
-    const readPrArtifactTyped = readPrArtifact;
-    const { prDir } = opts;
-    const diffstatPath = path.join(prDir, "diffstat.txt");
-    const verifyLogPath = path.join(prDir, "verify.log");
-    const reviewPath = path.join(prDir, "review.md");
-    const worktreePath = await findWorktreeForBranch(opts.resolved.gitRoot, opts.branch);
-    const errors = [];
-    const relDiffstat = path.relative(opts.resolved.gitRoot, diffstatPath);
-    const relVerifyLog = path.relative(opts.resolved.gitRoot, verifyLogPath);
-    const relReview = path.relative(opts.resolved.gitRoot, reviewPath);
-    const diffstatText = await readPrArtifactTyped({
-        resolved: opts.resolved,
-        prDir,
-        fileName: "diffstat.txt",
-        branch: opts.branch,
-        worktreePath,
-    });
-    if (diffstatText === null)
-        errors.push(`Missing ${relDiffstat}`);
-    const verifyLogText = await readPrArtifactTyped({
-        resolved: opts.resolved,
-        prDir,
-        fileName: "verify.log",
-        branch: opts.branch,
-        worktreePath,
-    });
-    if (verifyLogText === null)
-        errors.push(`Missing ${relVerifyLog}`);
-    const reviewText = await readPrArtifactTyped({
-        resolved: opts.resolved,
-        prDir,
-        fileName: "review.md",
-        branch: opts.branch,
-        worktreePath,
-    });
-    if (reviewText === null)
-        errors.push(`Missing ${relReview}`);
-    if (reviewText)
-        validateReviewContents(reviewText, errors);
-    if (errors.length > 0) {
-        throw new CliError({
-            exitCode: exitCodeForError("E_VALIDATION"),
-            code: "E_VALIDATION",
-            message: errors.join("\n"),
-        });
-    }
-    return { verifyLogText };
-}
-export async function ensureCommittedPrArtifactsOnBranch(opts) {
-    const readCommittedPrArtifact = readPrArtifactFromBranch;
-    const { prDir } = opts;
-    const diffstatPath = path.join(prDir, "diffstat.txt");
-    const verifyLogPath = path.join(prDir, "verify.log");
-    const reviewPath = path.join(prDir, "review.md");
-    const metaPath = path.join(prDir, "meta.json");
-    const errors = [];
-    const relMeta = path.relative(opts.resolved.gitRoot, metaPath);
-    const relDiffstat = path.relative(opts.resolved.gitRoot, diffstatPath);
-    const relVerifyLog = path.relative(opts.resolved.gitRoot, verifyLogPath);
-    const relReview = path.relative(opts.resolved.gitRoot, reviewPath);
-    const metaText = await readCommittedPrArtifact({
-        resolved: opts.resolved,
-        prDir,
-        fileName: "meta.json",
-        branch: opts.branch,
-    });
-    if (metaText === null)
-        errors.push(`Missing committed ${relMeta} on branch ${opts.branch}`);
-    const diffstatText = await readCommittedPrArtifact({
-        resolved: opts.resolved,
-        prDir,
-        fileName: "diffstat.txt",
-        branch: opts.branch,
-    });
-    if (diffstatText === null) {
-        errors.push(`Missing committed ${relDiffstat} on branch ${opts.branch}`);
-    }
-    const verifyLogText = await readCommittedPrArtifact({
-        resolved: opts.resolved,
-        prDir,
-        fileName: "verify.log",
-        branch: opts.branch,
-    });
-    if (verifyLogText === null) {
-        errors.push(`Missing committed ${relVerifyLog} on branch ${opts.branch}`);
-    }
-    const reviewText = await readCommittedPrArtifact({
-        resolved: opts.resolved,
-        prDir,
-        fileName: "review.md",
-        branch: opts.branch,
-    });
-    if (reviewText === null) {
-        errors.push(`Missing committed ${relReview} on branch ${opts.branch}`);
-    }
-    else {
-        validateReviewContents(reviewText, errors);
-    }
-    if (errors.length > 0) {
-        throw new CliError({
-            exitCode: exitCodeForError("E_VALIDATION"),
-            code: "E_VALIDATION",
-            message: `Task branch ${opts.branch} is missing committed PR artifacts required for integrate.\n` +
-                `${errors.join("\n")}\n` +
-                "Commit the task README/PR artifacts on the task branch (for example via `agentplane pr open` + git add/commit) before rerunning integrate.",
-        });
-    }
-}

package/dist/commands/pr/integrate/cmd.d.ts

@@ -1,14 +0,0 @@
-import type { CommandContext } from "../../shared/task-backend.js";
-export declare function cmdIntegrate(opts: {
-    ctx?: CommandContext;
-    cwd: string;
-    rootOverride?: string;
-    taskId: string;
-    branch?: string;
-    base?: string;
-    mergeStrategy: "squash" | "merge" | "rebase";
-    runVerify: boolean;
-    dryRun: boolean;
-    quiet: boolean;
-}): Promise<number>;
-//# sourceMappingURL=cmd.d.ts.map

package/dist/commands/pr/integrate/cmd.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"cmd.d.ts","sourceRoot":"","sources":["../../../../src/commands/pr/integrate/cmd.ts"],"names":[],"mappings":"AAiBA,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,8BAA8B,CAAC;AA0EnE,wBAAsB,YAAY,CAAC,IAAI,EAAE;IACvC,GAAG,CAAC,EAAE,cAAc,CAAC;IACrB,GAAG,EAAE,MAAM,CAAC;IACZ,YAAY,CAAC,EAAE,MAAM,CAAC;IACtB,MAAM,EAAE,MAAM,CAAC;IACf,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,IAAI,CAAC,EAAE,MAAM,CAAC;IACd,aAAa,EAAE,QAAQ,GAAG,OAAO,GAAG,QAAQ,CAAC;IAC7C,SAAS,EAAE,OAAO,CAAC;IACnB,MAAM,EAAE,OAAO,CAAC;IAChB,KAAK,EAAE,OAAO,CAAC;CAChB,GAAG,OAAO,CAAC,MAAM,CAAC,CA6QlB"}

package/dist/commands/pr/integrate/cmd.js

@@ -1,300 +0,0 @@
-import path from "node:path";
-import { mapBackendError } from "../../../cli/error-map.js";
-import { exitCodeForError } from "../../../cli/exit-codes.js";
-import { createCliEmitter } from "../../../cli/output.js";
-import { withDiagnosticContext } from "../../shared/diagnostics.js";
-import { CliError } from "../../../shared/errors.js";
-import { cleanupIntegratedBranch } from "./internal/cleanup.js";
-import { renderPostIntegrateBootstrapFailureGuidance, renderPostIntegrateBootstrapGuidance, shouldRecommendPostIntegrateBootstrap, } from "./internal/bootstrap-guidance.js";
-import { execFileAsync } from "@agentplaneorg/core/process";
-import { gitEnv } from "@agentplaneorg/core/git";
-import { gitRevParse } from "../../shared/git-ops.js";
-import { buildTaskHandoffArtifact, resolveTaskHandoffPaths, writeTaskHandoff, } from "../../shared/task-handoff.js";
-import { finalizeIntegrate } from "./internal/finalize.js";
-import { runMergeCommit, runRebaseFastForward, runSquashMerge } from "./internal/merge.js";
-import { maybeRunPreIntegrateBootstrap } from "./internal/pre-integrate-bootstrap.js";
-import { maybeRunPostIntegrateBootstrap } from "./internal/post-integrate-bootstrap.js";
-import { prepareIntegrate } from "./internal/prepare.js";
-import { resolveWorktreeForIntegrate } from "./internal/worktree.js";
-import { runVerifyCommands } from "./verify.js";
-async function recordProtectedBaseIntegrateHandoff(opts) {
-    const paths = resolveTaskHandoffPaths({
-        git_root: opts.ctx.resolvedProject.gitRoot,
-        workflow_dir: opts.ctx.config.paths.workflow_dir,
-        task_id: opts.taskId,
-    });
-    const handoffShowCommand = `agentplane task handoff show ${opts.taskId}`;
-    const prLabel = typeof opts.prNumber === "number" && opts.prNumber > 0
-        ? `GitHub PR #${opts.prNumber}`
-        : `the GitHub PR for branch ${opts.branch}`;
-    const prUrl = opts.prUrl?.trim() ?? "";
-    const prMetaPath = path.join(opts.ctx.config.paths.workflow_dir, opts.taskId, "pr", "meta.json");
-    const taskReadmePath = path.join(opts.ctx.config.paths.workflow_dir, opts.taskId, "README.md");
-    await writeTaskHandoff({
-        paths,
-        handoff: buildTaskHandoffArtifact({
-            task_id: opts.taskId,
-            created_at: new Date().toISOString(),
-            from_role: "INTEGRATOR",
-            reason: `Protected base ${opts.base} requires GitHub pull-request merges.`,
-            note: prUrl.length > 0
-                ? `Merge ${prLabel}: ${prUrl}. After GitHub merge, wait for Task Hosted Close, then pull ${opts.base}.`
-                : `Merge ${prLabel} on GitHub. After GitHub merge, wait for Task Hosted Close, then pull ${opts.base}.`,
-            branch: opts.branch,
-            base_branch: opts.base,
-            head_sha: opts.branchHeadSha,
-            workspace_root: opts.ctx.resolvedProject.gitRoot,
-            pr_branch: opts.branch,
-            route: {
-                kind: "protected_base_integrate",
-                status: "awaiting_github_merge",
-                local_mutation: "not_performed",
-                finalize_via: "github_pr_merge_then_hosted_close",
-                pr_number: opts.prNumber,
-                pr_url: prUrl.length > 0 ? prUrl : null,
-                handoff_show_command: handoffShowCommand,
-                base_pull_command: "git pull --ff-only",
-            },
-            next_actions: [
-                handoffShowCommand,
-                prUrl.length > 0 ? `Merge ${prLabel}: ${prUrl}` : `Merge ${prLabel} on GitHub`,
-                `Wait for Task Hosted Close to finish`,
-                `git pull --ff-only`,
-            ],
-            evidence_paths: [taskReadmePath, prMetaPath],
-        }),
-    });
-}
-export async function cmdIntegrate(opts) {
-    let tempWorktreePath = null;
-    let createdTempWorktree = false;
-    const output = createCliEmitter();
-    try {
-        const prepared = await prepareIntegrate({
-            ctx: opts.ctx,
-            cwd: opts.cwd,
-            rootOverride: opts.rootOverride,
-            taskId: opts.taskId,
-            branch: opts.branch,
-            base: opts.base,
-            runVerify: opts.runVerify,
-        });
-        const { resolved, loadedConfig, task, prDir, metaPath, diffstatPath, verifyLogPath, metaSource, branch, base, verifyLogText, protectedBaseRequiresPrMerge, } = prepared;
-        const verifyCommands = prepared.verifyCommands;
-        let alreadyVerifiedSha = prepared.alreadyVerifiedSha;
-        let shouldRunVerify = prepared.shouldRunVerify;
-        let branchHeadSha = prepared.branchHeadSha;
-        const changedPaths = prepared.changedPaths;
-        if (opts.dryRun) {
-            if (!opts.quiet) {
-                output.success("integrate dry-run", task.id, `base=${base} branch=${branch} verify=${shouldRunVerify ? "yes" : "no"} route=${protectedBaseRequiresPrMerge ? "github-pr" : "local"}`);
-            }
-            return 0;
-        }
-        if (protectedBaseRequiresPrMerge) {
-            const prNumber = typeof metaSource.pr_number === "number" && metaSource.pr_number > 0
-                ? metaSource.pr_number
-                : null;
-            const prUrl = typeof metaSource.pr_url === "string" ? metaSource.pr_url : null;
-            const prHint = prNumber === null ? `the GitHub PR for branch ${branch}` : `GitHub PR #${prNumber}`;
-            await recordProtectedBaseIntegrateHandoff({
-                ctx: prepared.ctx,
-                taskId: task.id,
-                branch,
-                base,
-                branchHeadSha,
-                prNumber,
-                prUrl,
-            });
-            throw new CliError({
-                exitCode: exitCodeForError("E_HANDOFF"),
-                code: "E_HANDOFF",
-                message: `Base branch ${base} requires GitHub pull-request merges; integrate will not mutate it locally. ` +
-                    `Merge ${prHint} on GitHub, let Task Hosted Close finish the closure tail, then pull ${base}.`,
-                context: withDiagnosticContext({
-                    task_id: task.id,
-                    branch,
-                    base_branch: base,
-                    reason_code: "protected_base_integrate_handoff",
-                }, {
-                    state: `protected-base integrate routed to GitHub merge handoff for ${task.id}`,
-                    likelyCause: `base branch ${base} is protected by a GitHub pull-request merge policy, so local integrate must stop before mutating ${base}`,
-                    hint: "Inspect the persisted handoff artifact for the canonical finalize route, then merge the PR on GitHub and let Task Hosted Close finish the close tail.",
-                    nextAction: {
-                        command: `agentplane task handoff show ${task.id}`,
-                        reason: "inspect the persisted protected-base finalize route before continuing",
-                        reasonCode: "protected_base_integrate_handoff",
-                    },
-                }),
-            });
-        }
-        const wt = await resolveWorktreeForIntegrate({
-            gitRoot: resolved.gitRoot,
-            worktreesDirRel: loadedConfig.paths.worktrees_dir,
-            branch,
-            taskId: task.id,
-            mergeStrategy: opts.mergeStrategy,
-            shouldRunVerify,
-        });
-        let worktreePath = wt.worktreePath;
-        tempWorktreePath = wt.tempWorktreePath;
-        createdTempWorktree = wt.createdTempWorktree;
-        const verifyEntries = [];
-        if (opts.mergeStrategy !== "rebase" && shouldRunVerify && verifyCommands.length > 0) {
-            if (!worktreePath) {
-                throw new CliError({
-                    exitCode: 2,
-                    code: "E_USAGE",
-                    message: "Unable to locate or create a worktree for verify execution",
-                });
-            }
-            verifyEntries.push(...(await runVerifyCommands({
-                commands: verifyCommands,
-                worktreePath,
-                branchHeadSha,
-                quiet: opts.quiet,
-                taskId: task.id,
-            })));
-        }
-        const preBootstrapResult = await maybeRunPreIntegrateBootstrap({
-            gitRoot: resolved.gitRoot,
-            changedPaths,
-        });
-        if (preBootstrapResult.status === "failed") {
-            throw new CliError({
-                exitCode: 8,
-                code: "E_RUNTIME",
-                message: "Unable to prepare the base worktree for integrate: automatic repo-local runtime refresh " +
-                    `failed (${preBootstrapResult.error}). Run \`bun run framework:dev:bootstrap\` in ${resolved.gitRoot} and retry integrate.`,
-            });
-        }
-        const baseShaBeforeMerge = await gitRevParse(resolved.gitRoot, [base]);
-        const headBeforeMerge = await gitRevParse(resolved.gitRoot, ["HEAD"]);
-        let mergeHash = "";
-        if (opts.mergeStrategy === "squash") {
-            mergeHash = await runSquashMerge({
-                gitRoot: resolved.gitRoot,
-                base,
-                branch,
-                headBeforeMerge,
-                taskId: task.id,
-                taskTitle: task.title,
-                taskTags: task.tags,
-                workflowDir: loadedConfig.paths.workflow_dir,
-                changedPaths,
-                genericTokens: loadedConfig.commit.generic_tokens,
-            });
-        }
-        else if (opts.mergeStrategy === "merge") {
-            mergeHash = await runMergeCommit({
-                gitRoot: resolved.gitRoot,
-                branch,
-                taskId: task.id,
-                taskTitle: task.title,
-                taskTags: task.tags,
-                workflowDir: loadedConfig.paths.workflow_dir,
-                changedPaths,
-            });
-        }
-        else {
-            if (!worktreePath) {
-                throw new CliError({
-                    exitCode: 2,
-                    code: "E_USAGE",
-                    message: "rebase strategy requires an existing worktree for the task branch",
-                });
-            }
-            const rebaseRes = await runRebaseFastForward({
-                gitRoot: resolved.gitRoot,
-                worktreePath,
-                base,
-                branch,
-                headBeforeMerge,
-                rawVerify: task.verify,
-                metaSource: metaSource ?? null,
-                verifyLogText,
-                runVerify: opts.runVerify,
-                verifyCommands,
-                alreadyVerifiedSha,
-                shouldRunVerify,
-                quiet: opts.quiet,
-                taskId: task.id,
-                workflowDir: loadedConfig.paths.workflow_dir,
-                changedPaths,
-            });
-            mergeHash = rebaseRes.mergeHash;
-            branchHeadSha = rebaseRes.branchHeadSha;
-            alreadyVerifiedSha = rebaseRes.alreadyVerifiedSha;
-            shouldRunVerify = rebaseRes.shouldRunVerify;
-            verifyEntries.push(...rebaseRes.verifyEntries);
-        }
-        await finalizeIntegrate({
-            ctx: prepared.ctx,
-            task,
-            cwd: opts.cwd,
-            rootOverride: opts.rootOverride,
-            gitRoot: resolved.gitRoot,
-            prDir,
-            metaPath,
-            diffstatPath,
-            verifyLogPath,
-            taskId: task.id,
-            branch,
-            base,
-            mergeStrategy: opts.mergeStrategy,
-            mergeHash,
-            branchHeadSha,
-            baseShaBeforeMerge,
-            verifyEntries,
-            verifyCommands,
-            alreadyVerifiedSha,
-            shouldRunVerify,
-            quiet: opts.quiet,
-        });
-        const cleanup = await cleanupIntegratedBranch({
-            gitRoot: resolved.gitRoot,
-            branch,
-            worktreePathHint: worktreePath,
-        });
-        if (cleanup.removedWorktree &&
-            cleanup.worktreePath &&
-            tempWorktreePath &&
-            path.resolve(cleanup.worktreePath) === path.resolve(tempWorktreePath)) {
-            tempWorktreePath = null;
-            createdTempWorktree = false;
-        }
-        if (shouldRecommendPostIntegrateBootstrap(changedPaths)) {
-            const bootstrapResult = await maybeRunPostIntegrateBootstrap({
-                gitRoot: resolved.gitRoot,
-                changedPaths,
-            });
-            if (!opts.quiet) {
-                if (bootstrapResult.status === "skipped") {
-                    output.warn(renderPostIntegrateBootstrapGuidance());
-                }
-                else if (bootstrapResult.status === "failed") {
-                    output.warn(renderPostIntegrateBootstrapFailureGuidance(bootstrapResult.error));
-                }
-            }
-        }
-        return 0;
-    }
-    catch (err) {
-        if (err instanceof CliError)
-            throw err;
-        throw mapBackendError(err, { command: "integrate", root: opts.rootOverride ?? null });
-    }
-    finally {
-        if (createdTempWorktree && tempWorktreePath) {
-            try {
-                await execFileAsync("git", ["worktree", "remove", "--force", tempWorktreePath], {
-                    cwd: opts.cwd,
-                    env: gitEnv(),
-                });
-            }
-            catch {
-                // ignore cleanup errors
-            }
-        }
-    }
-}

package/dist/commands/pr/integrate/internal/bootstrap-guidance.d.ts

@@ -1,8 +0,0 @@
-export declare function shouldRecommendPostIntegrateBootstrap(changedPaths: string[]): boolean;
-export declare function shouldAutoBootstrapAfterIntegrate(opts: {
-    changedPaths: string[];
-    gitRoot: string;
-}): boolean;
-export declare function renderPostIntegrateBootstrapGuidance(): string;
-export declare function renderPostIntegrateBootstrapFailureGuidance(reason: string): string;
-//# sourceMappingURL=bootstrap-guidance.d.ts.map

package/dist/commands/pr/integrate/internal/bootstrap-guidance.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"bootstrap-guidance.d.ts","sourceRoot":"","sources":["../../../../../src/commands/pr/integrate/internal/bootstrap-guidance.ts"],"names":[],"mappings":"AA4CA,wBAAgB,qCAAqC,CAAC,YAAY,EAAE,MAAM,EAAE,GAAG,OAAO,CAErF;AAED,wBAAgB,iCAAiC,CAAC,IAAI,EAAE;IACtD,YAAY,EAAE,MAAM,EAAE,CAAC;IACvB,OAAO,EAAE,MAAM,CAAC;CACjB,GAAG,OAAO,CASV;AAED,wBAAgB,oCAAoC,IAAI,MAAM,CAK7D;AAED,wBAAgB,2CAA2C,CAAC,MAAM,EAAE,MAAM,GAAG,MAAM,CAKlF"}

package/dist/commands/pr/integrate/internal/bootstrap-guidance.js

@@ -1,59 +0,0 @@
-import { existsSync } from "node:fs";
-import path from "node:path";
-import { isRuntimeRelevantWatchedFile } from "../../../../../bin/runtime-watch.js";
-const WATCHED_RUNTIME_PACKAGES = [
-    {
-        packageRoot: "packages/agentplane",
-        watchedPaths: [
-            "src",
-            "bin/agentplane.js",
-            "bin/dist-guard.js",
-            "bin/runtime-context.js",
-            "bin/stale-dist-policy.js",
-        ],
-    },
-    {
-        packageRoot: "packages/core",
-        watchedPaths: ["src"],
-    },
-];
-function normalizeRepoPath(filePath) {
-    return filePath.replaceAll("\\", "/");
-}
-function isWatchedRuntimeSourcePath(filePath) {
-    const normalized = normalizeRepoPath(filePath);
-    for (const watchedPackage of WATCHED_RUNTIME_PACKAGES) {
-        for (const watchedPath of watchedPackage.watchedPaths) {
-            if (watchedPath === "src") {
-                const sourcePrefix = `${watchedPackage.packageRoot}/src/`;
-                if (!normalized.startsWith(sourcePrefix))
-                    continue;
-                const packageRelativePath = normalized.slice(watchedPackage.packageRoot.length + 1);
-                return isRuntimeRelevantWatchedFile(packageRelativePath);
-            }
-            if (normalized === `${watchedPackage.packageRoot}/${watchedPath}`) {
-                return true;
-            }
-        }
-    }
-    return false;
-}
-export function shouldRecommendPostIntegrateBootstrap(changedPaths) {
-    return changedPaths.some((changedPath) => isWatchedRuntimeSourcePath(changedPath));
-}
-export function shouldAutoBootstrapAfterIntegrate(opts) {
-    if (!shouldRecommendPostIntegrateBootstrap(opts.changedPaths)) {
-        return false;
-    }
-    return (existsSync(path.join(opts.gitRoot, "package.json")) &&
-        existsSync(path.join(opts.gitRoot, "packages", "agentplane", "package.json")) &&
-        existsSync(path.join(opts.gitRoot, "scripts", "bootstrap-framework-dev.mjs")));
-}
-export function renderPostIntegrateBootstrapGuidance() {
-    return ("This merge changed watched runtime sources. Run `bun run framework:dev:bootstrap` " +
-        "before the next command so the repo-local build stays current.");
-}
-export function renderPostIntegrateBootstrapFailureGuidance(reason) {
-    return ("This merge changed watched runtime sources and the automatic repo-local runtime refresh " +
-        `failed (${reason}). Run \`bun run framework:dev:bootstrap\` manually before the next command.`);
-}

package/dist/commands/pr/integrate/internal/cleanup.d.ts

@@ -1,2 +0,0 @@
-export { cleanupMergedLocalBranch as cleanupIntegratedBranch } from "../../../shared/merged-branch-cleanup.js";
-//# sourceMappingURL=cleanup.d.ts.map

package/dist/commands/pr/integrate/internal/cleanup.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"cleanup.d.ts","sourceRoot":"","sources":["../../../../../src/commands/pr/integrate/internal/cleanup.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,wBAAwB,IAAI,uBAAuB,EAAE,MAAM,0CAA0C,CAAC"}

package/dist/commands/pr/integrate/internal/cleanup.js

@@ -1 +0,0 @@
-export { cleanupMergedLocalBranch as cleanupIntegratedBranch } from "../../../shared/merged-branch-cleanup.js";

package/dist/commands/pr/integrate/internal/finalize.d.ts

@@ -1,29 +0,0 @@
-import type { TaskData } from "../../../../backends/task-backend.js";
-import type { CommandContext } from "../../../shared/task-backend.js";
-export declare function finalizeIntegrate(opts: {
-    ctx: CommandContext;
-    task: TaskData;
-    cwd: string;
-    rootOverride?: string;
-    gitRoot: string;
-    prDir: string;
-    metaPath: string;
-    diffstatPath: string;
-    verifyLogPath: string;
-    taskId: string;
-    branch: string;
-    base: string;
-    mergeStrategy: "squash" | "merge" | "rebase";
-    mergeHash: string;
-    branchHeadSha: string;
-    baseShaBeforeMerge: string;
-    verifyEntries: {
-        header: string;
-        content: string;
-    }[];
-    verifyCommands: string[];
-    alreadyVerifiedSha: string | null;
-    shouldRunVerify: boolean;
-    quiet: boolean;
-}): Promise<void>;
-//# sourceMappingURL=finalize.d.ts.map

package/dist/commands/pr/integrate/internal/finalize.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"finalize.d.ts","sourceRoot":"","sources":["../../../../../src/commands/pr/integrate/internal/finalize.ts"],"names":[],"mappings":"AAIA,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,sCAAsC,CAAC;AAiBrE,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,iCAAiC,CAAC;AAUtE,wBAAsB,iBAAiB,CAAC,IAAI,EAAE;IAC5C,GAAG,EAAE,cAAc,CAAC;IACpB,IAAI,EAAE,QAAQ,CAAC;IACf,GAAG,EAAE,MAAM,CAAC;IACZ,YAAY,CAAC,EAAE,MAAM,CAAC;IACtB,OAAO,EAAE,MAAM,CAAC;IAChB,KAAK,EAAE,MAAM,CAAC;IACd,QAAQ,EAAE,MAAM,CAAC;IACjB,YAAY,EAAE,MAAM,CAAC;IACrB,aAAa,EAAE,MAAM,CAAC;IACtB,MAAM,EAAE,MAAM,CAAC;IAEf,MAAM,EAAE,MAAM,CAAC;IACf,IAAI,EAAE,MAAM,CAAC;IACb,aAAa,EAAE,QAAQ,GAAG,OAAO,GAAG,QAAQ,CAAC;IAC7C,SAAS,EAAE,MAAM,CAAC;IAClB,aAAa,EAAE,MAAM,CAAC;IACtB,kBAAkB,EAAE,MAAM,CAAC;IAE3B,aAAa,EAAE;QAAE,MAAM,EAAE,MAAM,CAAC;QAAC,OAAO,EAAE,MAAM,CAAA;KAAE,EAAE,CAAC;IACrD,cAAc,EAAE,MAAM,EAAE,CAAC;IACzB,kBAAkB,EAAE,MAAM,GAAG,IAAI,CAAC;IAClC,eAAe,EAAE,OAAO,CAAC;IAEzB,KAAK,EAAE,OAAO,CAAC;CAChB,GAAG,OAAO,CAAC,IAAI,CAAC,CA2GhB"}

package/dist/commands/pr/integrate/internal/finalize.js

@@ -1,112 +0,0 @@
-import path from "node:path";
-import { readFile } from "node:fs/promises";
-import { normalizeTaskStatus } from "@agentplaneorg/core/tasks";
-import { fileExists } from "../../../../cli/fs-utils.js";
-import { createCliEmitter } from "../../../../cli/output.js";
-import { CliError } from "../../../../shared/errors.js";
-import { writeJsonStableIfChanged, writeTextIfChanged, } from "../../../../shared/write-if-changed.js";
-import { gitDiffStat } from "@agentplaneorg/core/git";
-import { appendVerifyLog, buildIntegratedPrMeta, parsePrMeta, } from "../../../shared/pr-meta.js";
-import { readCommitInfo } from "../../../task/shared.js";
-import { createTaskCloseCommit, writeFinishedTasks } from "../../../task/finish-shared.js";
-import { collectTaskIncidents, renderIncidentCollectionPlanOutcome, } from "../../../incidents/shared.js";
-function nowIso() {
-    return new Date().toISOString();
-}
-export async function finalizeIntegrate(opts) {
-    const output = createCliEmitter();
-    const taskAlreadyDone = normalizeTaskStatus(opts.task.status) === "DONE";
-    if (!(await fileExists(opts.prDir))) {
-        throw new CliError({
-            exitCode: 3,
-            code: "E_VALIDATION",
-            message: `Missing PR artifact dir after merge: ${path.relative(opts.gitRoot, opts.prDir)}`,
-        });
-    }
-    if (opts.verifyEntries.length > 0) {
-        for (const entry of opts.verifyEntries) {
-            await appendVerifyLog(opts.verifyLogPath, entry.header, entry.content);
-        }
-    }
-    const rawMeta = await readFile(opts.metaPath, "utf8");
-    const mergedMeta = parsePrMeta(rawMeta, opts.taskId);
-    const now = nowIso();
-    const nextMeta = buildIntegratedPrMeta({
-        meta: mergedMeta,
-        branch: opts.branch,
-        base: opts.base,
-        mergeStrategy: opts.mergeStrategy,
-        mergeHash: opts.mergeHash,
-        branchHeadSha: opts.branchHeadSha,
-        at: now,
-        verifyCommands: opts.verifyCommands,
-        shouldRunVerify: opts.shouldRunVerify,
-        alreadyVerifiedSha: opts.alreadyVerifiedSha,
-    });
-    await writeJsonStableIfChanged(opts.metaPath, nextMeta);
-    const diffstat = await gitDiffStat(opts.gitRoot, opts.baseShaBeforeMerge, opts.branch);
-    await writeTextIfChanged(opts.diffstatPath, diffstat ? `${diffstat}\n` : "");
-    const verifyDesc = opts.verifyCommands.length === 0
-        ? "skipped(no commands)"
-        : opts.shouldRunVerify
-            ? "ran"
-            : opts.alreadyVerifiedSha
-                ? `skipped(already verified_sha=${opts.alreadyVerifiedSha})`
-                : "skipped";
-    const finishBody = `Verified: Integrated via ${opts.mergeStrategy}; verify=${verifyDesc}; pr=${path.relative(opts.gitRoot, opts.prDir)}.`;
-    const resultSummary = `integrate: ${opts.mergeStrategy} ${opts.branch}`;
-    await collectTaskIncidents({
-        ctx: opts.ctx,
-        taskId: opts.taskId,
-        task: opts.task,
-        write: false,
-    });
-    if (!taskAlreadyDone) {
-        const taskCommitInfo = await readCommitInfo(opts.gitRoot, opts.mergeHash);
-        await writeFinishedTasks({
-            ctx: opts.ctx,
-            loadedTasks: [{ taskId: opts.taskId, task: opts.task }],
-            metaTaskId: opts.taskId,
-            author: "INTEGRATOR",
-            body: finishBody,
-            force: false,
-            resultProvided: true,
-            resultSummary,
-            riskLevel: undefined,
-            breaking: false,
-            taskCommitInfo,
-        });
-    }
-    const collectedIncidents = await collectTaskIncidents({
-        ctx: opts.ctx,
-        taskId: opts.taskId,
-        task: opts.task,
-        write: true,
-    });
-    if (!opts.quiet) {
-        output.info(renderIncidentCollectionPlanOutcome(collectedIncidents.plan, {
-            wrote: collectedIncidents.wrote,
-            context: "finish",
-            promotedIds: collectedIncidents.plan.promotable.map((item) => item.entry.id),
-            registryPaths: collectedIncidents.registryPaths,
-        }));
-        if (taskAlreadyDone) {
-            output.info("task already DONE; integrating only missing PR metadata and close artifacts");
-        }
-    }
-    await createTaskCloseCommit({
-        ctx: opts.ctx,
-        cwd: opts.cwd,
-        rootOverride: opts.rootOverride,
-        taskId: opts.taskId,
-        baseBranchOverride: opts.base,
-        quiet: opts.quiet,
-        allowPolicy: collectedIncidents.wrote,
-        // finalizeIntegrate already wrote the canonical MERGED task packet on the base checkout.
-        // Re-running branch-side PR artifact refresh here can regress pr/meta.json back to OPEN.
-        closeRefreshTaskArtifacts: false,
-    });
-    if (!opts.quiet) {
-        output.success("integrate", opts.taskId, `merge=${opts.mergeHash.slice(0, 12)}`);
-    }
-}

package/dist/commands/pr/integrate/internal/github-protection.d.ts

@@ -1,5 +0,0 @@
-export declare function requiresPullRequestMergePath(opts: {
-    gitRoot: string;
-    baseBranch: string;
-}): Promise<boolean>;
-//# sourceMappingURL=github-protection.d.ts.map