@junctionpanel/server 0.1.20 → 0.1.22

package/dist/server/utils/checkout-git.js

@@ -379,6 +379,19 @@ async function getWorktreeRoot(cwd) {
         return null;
     }
 }
+async function getUpstreamBranch(cwd) {
+    try {
+        const { stdout } = await execAsync("git rev-parse --abbrev-ref --symbolic-full-name @{upstream}", {
+            cwd,
+            env: READ_ONLY_GIT_ENV,
+        });
+        const upstream = stdout.trim();
+        return upstream.length > 0 ? upstream : null;
+    }
+    catch {
+        return null;
+    }
+}
 async function getMainRepoRoot(cwd) {
     const { stdout: commonDirOut } = await execAsync("git rev-parse --path-format=absolute --git-common-dir", { cwd, env: READ_ONLY_GIT_ENV });
     const commonDir = commonDirOut.trim();
@@ -738,11 +751,13 @@ export async function getCheckoutStatus(cwd, context) {
     const isDirty = await isWorkingTreeDirty(cwd);
     const hasRemote = remoteUrl !== null;
     const baseRef = configured.baseRef ?? (await resolveBaseRef(cwd));
+    const upstreamBranch = currentBranch ? await getUpstreamBranch(cwd) : null;
     const [aheadBehind, aheadOfOrigin, behindOfOrigin] = await Promise.all([
         baseRef && currentBranch ? getAheadBehind(cwd, baseRef, currentBranch) : Promise.resolve(null),
         hasRemote && currentBranch ? getAheadOfOrigin(cwd, currentBranch) : Promise.resolve(null),
         hasRemote && currentBranch ? getBehindOfOrigin(cwd, currentBranch) : Promise.resolve(null),
     ]);
+    const hasUpstream = upstreamBranch !== null;
     if (configured.isJunctionOwnedWorktree) {
         const mainRepoRoot = await getMainRepoRoot(cwd);
         return {
@@ -755,6 +770,8 @@ export async function getCheckoutStatus(cwd, context) {
             aheadBehind,
             aheadOfOrigin,
             behindOfOrigin,
+            hasUpstream,
+            upstreamBranch,
             hasRemote,
             remoteUrl,
             isJunctionOwnedWorktree: true,
@@ -769,6 +786,8 @@ export async function getCheckoutStatus(cwd, context) {
         aheadBehind,
         aheadOfOrigin,
         behindOfOrigin,
+        hasUpstream,
+        upstreamBranch,
         hasRemote,
         remoteUrl,
         isJunctionOwnedWorktree: false,
@@ -1200,6 +1219,9 @@ export async function pushCurrentBranch(cwd) {
     }
     await execAsync(`git push -u origin ${currentBranch}`, { cwd });
 }
+const GH_JSON_MAX_BYTES = 512 * 1024;
+const GH_FAILED_LOG_MAX_BYTES = 200 * 1024;
+const GH_FAILED_LOG_TOTAL_MAX_BYTES = 300 * 1024;
 async function ensureGhAvailable(cwd) {
     try {
         await execAsync("gh --version", { cwd });
@@ -1282,13 +1304,18 @@ async function listPullRequestsForHead(options) {
     const parsed = JSON.parse(stdout.trim());
     return Array.isArray(parsed) ? parsed : [];
 }
-function buildPullRequestStatus(current, fallbackHead) {
+function buildPullRequestBaseStatus(current, fallbackHead) {
     if (!current || typeof current !== "object") {
         return null;
     }
+    const number = typeof current.number === "number" && Number.isFinite(current.number) ? current.number : null;
     const url = current.html_url ?? current.url;
     const title = current.title;
-    if (typeof url !== "string" || typeof title !== "string" || !url || !title) {
+    if (number === null ||
+        typeof url !== "string" ||
+        typeof title !== "string" ||
+        !url ||
+        !title) {
         return null;
     }
     const mergedAt = typeof current.merged_at === "string" && current.merged_at.trim().length > 0
@@ -1300,49 +1327,346 @@ function buildPullRequestStatus(current, fallbackHead) {
             ? current.state
             : "";
     return {
+        number,
         url,
         title,
         state,
         baseRefName: current.base?.ref ?? "",
         headRefName: current.head?.ref ?? fallbackHead,
         isMerged: mergedAt !== null,
+        draft: Boolean(current.draft),
+        headSha: typeof current.head?.sha === "string" ? current.head.sha : null,
     };
 }
-export async function createPullRequest(cwd, options) {
-    await requireGitRepo(cwd);
-    await ensureGhAvailable(cwd);
-    const repo = await resolveGitHubRepo(cwd);
-    if (!repo) {
-        throw new Error("Unable to determine GitHub repo from git remote");
+function normalizeCheckBucket(value, state) {
+    if (value === "pass" || value === "fail" || value === "pending" || value === "skipping" || value === "cancel") {
+        return value;
+    }
+    const normalizedState = state.toLowerCase();
+    if (normalizedState === "success" ||
+        normalizedState === "neutral" ||
+        normalizedState === "skipped") {
+        return "pass";
+    }
+    if (normalizedState === "failure" ||
+        normalizedState === "error" ||
+        normalizedState === "timed_out" ||
+        normalizedState === "startup_failure" ||
+        normalizedState === "action_required") {
+        return "fail";
+    }
+    if (normalizedState === "cancelled") {
+        return "cancel";
+    }
+    if (normalizedState === "queued" ||
+        normalizedState === "waiting" ||
+        normalizedState === "requested" ||
+        normalizedState === "pending" ||
+        normalizedState === "in_progress") {
+        return "pending";
     }
-    const head = options.head ?? (await getCurrentBranch(cwd));
-    const configured = await getConfiguredBaseRefForCwd(cwd);
-    const base = configured.baseRef ?? options.base ?? (await resolveBaseRef(cwd));
-    if (!head) {
-        throw new Error("Unable to determine head branch for PR");
+    return null;
+}
+function parsePullRequestChecks(input) {
+    if (!Array.isArray(input)) {
+        return [];
     }
-    if (!base) {
-        throw new Error("Unable to determine base branch for PR");
+    return input
+        .map((entry) => {
+        if (!entry || typeof entry !== "object") {
+            return null;
+        }
+        const state = typeof entry.state === "string" ? entry.state : "";
+        const bucket = normalizeCheckBucket(entry.bucket, state);
+        const name = typeof entry.name === "string" ? entry.name.trim() : "";
+        if (!bucket || !name) {
+            return null;
+        }
+        return {
+            name,
+            workflow: typeof entry.workflow === "string" && entry.workflow.trim().length > 0
+                ? entry.workflow.trim()
+                : null,
+            link: typeof entry.link === "string" && entry.link.trim().length > 0 ? entry.link : null,
+            description: typeof entry.description === "string" && entry.description.trim().length > 0
+                ? entry.description.trim()
+                : null,
+            state,
+            bucket,
+        };
+    })
+        .filter((entry) => entry !== null);
+}
+async function getRequiredPullRequestChecks(cwd, prNumber) {
+    let result;
+    try {
+        result = await spawnLimitedText({
+            cmd: "gh",
+            args: [
+                "pr",
+                "checks",
+                String(prNumber),
+                "--required",
+                "--json",
+                "bucket,description,link,name,state,workflow",
+            ],
+            cwd,
+            maxBytes: GH_JSON_MAX_BYTES,
+            acceptExitCodes: [0, 1, 8],
+        });
     }
-    const normalizedBase = normalizeLocalBranchRefName(base);
-    if (configured.isJunctionOwnedWorktree && options.base && options.base !== base) {
-        throw new Error(`Base ref mismatch: expected ${base}, got ${options.base}`);
+    catch (error) {
+        if (getCommandErrorText(error).includes("no checks reported")) {
+            return [];
+        }
+        throw error;
     }
-    await execAsync(`git push -u origin ${head}`, { cwd });
-    const args = ["api", "-X", "POST", `repos/${repo}/pulls`, "-f", `title=${options.title}`];
-    args.push("-f", `head=${head}`);
-    args.push("-f", `base=${normalizedBase}`);
-    if (options.body) {
-        args.push("-f", `body=${options.body}`);
+    const text = result.text.trim();
+    if (!text) {
+        return [];
     }
-    const { stdout } = await execFileAsync("gh", args, { cwd });
-    const parsed = JSON.parse(stdout.trim());
-    if (!parsed?.url || !parsed?.number) {
-        throw new Error("GitHub CLI did not return PR url/number");
+    return parsePullRequestChecks(JSON.parse(text));
+}
+function parseStatusCheckRollup(input) {
+    if (!Array.isArray(input)) {
+        return [];
     }
-    return { url: parsed.url, number: parsed.number };
+    return input
+        .map((entry) => {
+        if (!entry || typeof entry !== "object") {
+            return null;
+        }
+        const statusValue = typeof entry.status === "string" && entry.status.trim().length > 0
+            ? entry.status.trim()
+            : typeof entry.state === "string" && entry.state.trim().length > 0
+                ? entry.state.trim()
+                : "";
+        const conclusionValue = typeof entry.conclusion === "string" && entry.conclusion.trim().length > 0
+            ? entry.conclusion.trim()
+            : "";
+        const bucket = normalizeCheckBucket(undefined, conclusionValue || statusValue) ??
+            (statusValue.toLowerCase() === "completed" && conclusionValue
+                ? normalizeCheckBucket(undefined, conclusionValue)
+                : null);
+        const name = typeof entry.name === "string" && entry.name.trim().length > 0
+            ? entry.name.trim()
+            : typeof entry.context === "string" && entry.context.trim().length > 0
+                ? entry.context.trim()
+                : "";
+        if (!bucket || !name) {
+            return null;
+        }
+        return {
+            name,
+            workflow: typeof entry.workflowName === "string" && entry.workflowName.trim().length > 0
+                ? entry.workflowName.trim()
+                : null,
+            link: typeof entry.detailsUrl === "string" && entry.detailsUrl.trim().length > 0
+                ? entry.detailsUrl.trim()
+                : typeof entry.targetUrl === "string" && entry.targetUrl.trim().length > 0
+                    ? entry.targetUrl.trim()
+                    : null,
+            description: typeof entry.description === "string" && entry.description.trim().length > 0
+                ? entry.description.trim()
+                : null,
+            state: conclusionValue || statusValue,
+            bucket,
+        };
+    })
+        .filter((entry) => entry !== null);
 }
-export async function getPullRequestStatus(cwd) {
+function mergeCheckStatuses(requiredChecks, rollupChecks) {
+    const merged = new Map();
+    for (const check of rollupChecks) {
+        const key = `${check.workflow ?? ""}::${check.name}`;
+        merged.set(key, check);
+    }
+    for (const check of requiredChecks) {
+        const key = `${check.workflow ?? ""}::${check.name}`;
+        merged.set(key, check);
+    }
+    return Array.from(merged.values());
+}
+function deriveChecksState(checks) {
+    if (checks.some((check) => check.bucket === "fail" || check.bucket === "cancel")) {
+        return "failing";
+    }
+    if (checks.some((check) => check.bucket === "pending")) {
+        return "pending";
+    }
+    return "passing";
+}
+async function getPullRequestMergeability(cwd, prNumber) {
+    const result = await spawnLimitedText({
+        cmd: "gh",
+        args: [
+            "pr",
+            "view",
+            String(prNumber),
+            "--json",
+            "mergeable,mergeStateStatus,statusCheckRollup",
+        ],
+        cwd,
+        maxBytes: GH_JSON_MAX_BYTES,
+    });
+    const text = result.text.trim();
+    if (!text) {
+        return { hasConflicts: false, rollupChecks: [] };
+    }
+    const parsed = JSON.parse(text);
+    const mergeable = typeof parsed.mergeable === "string" ? parsed.mergeable.trim().toUpperCase() : "";
+    const mergeStateStatus = typeof parsed.mergeStateStatus === "string"
+        ? parsed.mergeStateStatus.trim().toUpperCase()
+        : "";
+    return {
+        hasConflicts: mergeable === "CONFLICTING" || mergeStateStatus === "DIRTY",
+        rollupChecks: parseStatusCheckRollup(parsed.statusCheckRollup),
+    };
+}
+function toPullRequestStatus(baseStatus, checks, mergeability) {
+    const checksState = baseStatus.isMerged ? "passing" : deriveChecksState(checks);
+    const requiredChecksPassed = baseStatus.isMerged
+        ? true
+        : checks.every((check) => check.bucket === "pass" || check.bucket === "skipping");
+    const hasConflicts = baseStatus.isMerged ? false : (mergeability?.hasConflicts ?? false);
+    return {
+        number: baseStatus.number,
+        url: baseStatus.url,
+        title: baseStatus.title,
+        state: baseStatus.state,
+        baseRefName: baseStatus.baseRefName,
+        headRefName: baseStatus.headRefName,
+        isMerged: baseStatus.isMerged,
+        checksState,
+        requiredChecksPassed,
+        canMerge: !baseStatus.isMerged && !baseStatus.draft && requiredChecksPassed && !hasConflicts,
+        hasConflicts,
+    };
+}
+async function listWorkflowRunsForHead(options) {
+    const args = [
+        "run",
+        "list",
+        "--json",
+        "conclusion,createdAt,databaseId,displayTitle,name,status,url,workflowName",
+        "-L",
+        "50",
+    ];
+    if (options.headSha) {
+        args.push("--commit", options.headSha);
+    }
+    else {
+        args.push("--branch", options.headBranch);
+    }
+    const result = await spawnLimitedText({
+        cmd: "gh",
+        args,
+        cwd: options.cwd,
+        maxBytes: GH_JSON_MAX_BYTES,
+    });
+    const text = result.text.trim();
+    if (!text) {
+        return [];
+    }
+    const parsed = JSON.parse(text);
+    if (!Array.isArray(parsed)) {
+        return [];
+    }
+    return parsed
+        .map((entry) => {
+        if (!entry || typeof entry !== "object") {
+            return null;
+        }
+        const databaseId = typeof entry.databaseId === "number" && Number.isFinite(entry.databaseId)
+            ? entry.databaseId
+            : null;
+        if (databaseId === null) {
+            return null;
+        }
+        return {
+            databaseId,
+            workflowName: typeof entry.workflowName === "string" && entry.workflowName.trim().length > 0
+                ? entry.workflowName.trim()
+                : null,
+            name: typeof entry.name === "string" && entry.name.trim().length > 0 ? entry.name.trim() : null,
+            displayTitle: typeof entry.displayTitle === "string" && entry.displayTitle.trim().length > 0
+                ? entry.displayTitle.trim()
+                : null,
+            url: typeof entry.url === "string" && entry.url.trim().length > 0 ? entry.url.trim() : null,
+            status: typeof entry.status === "string" && entry.status.trim().length > 0
+                ? entry.status.trim()
+                : null,
+            conclusion: typeof entry.conclusion === "string" && entry.conclusion.trim().length > 0
+                ? entry.conclusion.trim()
+                : null,
+            createdAt: typeof entry.createdAt === "string" && entry.createdAt.trim().length > 0
+                ? entry.createdAt.trim()
+                : null,
+        };
+    })
+        .filter((entry) => entry !== null);
+}
+function isWorkflowRunFailed(run) {
+    const conclusion = run.conclusion?.toLowerCase() ?? "";
+    return (conclusion === "failure" ||
+        conclusion === "cancelled" ||
+        conclusion === "timed_out" ||
+        conclusion === "startup_failure" ||
+        conclusion === "action_required");
+}
+function findRunsForFailingChecks(checks, runs) {
+    const failedRuns = runs.filter(isWorkflowRunFailed);
+    const selected = [];
+    const seen = new Set();
+    for (const check of checks) {
+        if (check.bucket !== "fail" && check.bucket !== "cancel") {
+            continue;
+        }
+        const matchingRun = failedRuns.find((run) => check.workflow !== null &&
+            (run.workflowName === check.workflow || run.name === check.workflow)) ??
+            failedRuns.find((run) => run.name === check.name || run.displayTitle === check.name) ??
+            null;
+        if (matchingRun && !seen.has(matchingRun.databaseId)) {
+            seen.add(matchingRun.databaseId);
+            selected.push(matchingRun);
+        }
+    }
+    if (selected.length > 0) {
+        return selected;
+    }
+    return failedRuns.slice(0, 3);
+}
+async function getFailedWorkflowRunLog(cwd, runId) {
+    const result = await spawnLimitedText({
+        cmd: "gh",
+        args: ["run", "view", String(runId), "--log-failed"],
+        cwd,
+        maxBytes: GH_FAILED_LOG_MAX_BYTES,
+    });
+    const text = result.text.trim();
+    if (!text) {
+        return "No failed-step logs were returned by GitHub CLI.";
+    }
+    return result.truncated ? `${text}\n\n[log truncated]` : text;
+}
+function appendBoundedText(parts, next, currentBytes) {
+    if (currentBytes >= GH_FAILED_LOG_TOTAL_MAX_BYTES) {
+        return currentBytes;
+    }
+    const nextBytes = Buffer.byteLength(next, "utf8");
+    if (currentBytes + nextBytes <= GH_FAILED_LOG_TOTAL_MAX_BYTES) {
+        parts.push(next);
+        return currentBytes + nextBytes;
+    }
+    const remaining = GH_FAILED_LOG_TOTAL_MAX_BYTES - currentBytes;
+    if (remaining <= 0) {
+        return currentBytes;
+    }
+    const truncated = Buffer.from(next, "utf8").subarray(0, remaining).toString("utf8");
+    parts.push(`${truncated}\n\n[combined log output truncated]`);
+    return GH_FAILED_LOG_TOTAL_MAX_BYTES;
+}
+async function loadCurrentPullRequest(cwd) {
     await requireGitRepo(cwd);
     const repo = await resolveGitHubRepo(cwd);
     const head = await getCurrentBranch(cwd);
@@ -1350,6 +1674,8 @@ export async function getPullRequestStatus(cwd) {
         return {
             status: null,
             githubFeaturesEnabled: false,
+            checks: [],
+            headSha: null,
         };
     }
     try {
@@ -1359,6 +1685,8 @@ export async function getPullRequestStatus(cwd) {
         return {
             status: null,
             githubFeaturesEnabled: false,
+            checks: [],
+            headSha: null,
         };
     }
     const owner = repo.split("/")[0];
@@ -1377,16 +1705,49 @@ export async function getPullRequestStatus(cwd) {
             return {
                 status: null,
                 githubFeaturesEnabled: false,
+                checks: [],
+                headSha: null,
             };
         }
         throw error;
     }
     const openPull = openPulls[0] ?? null;
-    const openStatus = buildPullRequestStatus(openPull, head);
-    if (openStatus) {
+    const openBaseStatus = buildPullRequestBaseStatus(openPull, head);
+    if (openBaseStatus) {
+        let checks;
+        let mergeability = { hasConflicts: false, rollupChecks: [] };
+        try {
+            checks = await getRequiredPullRequestChecks(cwd, openBaseStatus.number);
+        }
+        catch (error) {
+            if (isGhAuthError(error)) {
+                return {
+                    status: null,
+                    githubFeaturesEnabled: false,
+                    checks: [],
+                    headSha: null,
+                };
+            }
+            throw error;
+        }
+        try {
+            mergeability = await getPullRequestMergeability(cwd, openBaseStatus.number);
+        }
+        catch (error) {
+            if (isGhAuthError(error)) {
+                return {
+                    status: null,
+                    githubFeaturesEnabled: false,
+                    checks: [],
+                    headSha: null,
+                };
+            }
+        }
         return {
-            status: openStatus,
+            status: toPullRequestStatus(openBaseStatus, mergeCheckStatuses(checks, mergeability.rollupChecks), mergeability),
             githubFeaturesEnabled: true,
+            checks: mergeCheckStatuses(checks, mergeability.rollupChecks),
+            headSha: openBaseStatus.headSha,
         };
     }
     let closedPulls;
@@ -1404,6 +1765,8 @@ export async function getPullRequestStatus(cwd) {
             return {
                 status: null,
                 githubFeaturesEnabled: false,
+                checks: [],
+                headSha: null,
             };
         }
         throw error;
@@ -1412,16 +1775,150 @@ export async function getPullRequestStatus(cwd) {
         typeof entry === "object" &&
         typeof entry.merged_at === "string" &&
         entry.merged_at.trim().length > 0) ?? null;
-    const mergedStatus = buildPullRequestStatus(mergedClosedPull, head);
-    if (!mergedStatus) {
+    const mergedBaseStatus = buildPullRequestBaseStatus(mergedClosedPull, head);
+    if (!mergedBaseStatus) {
         return {
             status: null,
             githubFeaturesEnabled: true,
+            checks: [],
+            headSha: null,
         };
     }
     return {
-        status: mergedStatus,
+        status: toPullRequestStatus(mergedBaseStatus, []),
         githubFeaturesEnabled: true,
+        checks: [],
+        headSha: mergedBaseStatus.headSha,
     };
 }
+export async function createPullRequest(cwd, options) {
+    await requireGitRepo(cwd);
+    await ensureGhAvailable(cwd);
+    const repo = await resolveGitHubRepo(cwd);
+    if (!repo) {
+        throw new Error("Unable to determine GitHub repo from git remote");
+    }
+    const head = options.head ?? (await getCurrentBranch(cwd));
+    const configured = await getConfiguredBaseRefForCwd(cwd);
+    const base = configured.baseRef ?? options.base ?? (await resolveBaseRef(cwd));
+    if (!head) {
+        throw new Error("Unable to determine head branch for PR");
+    }
+    if (!base) {
+        throw new Error("Unable to determine base branch for PR");
+    }
+    const normalizedBase = normalizeLocalBranchRefName(base);
+    if (configured.isJunctionOwnedWorktree && options.base && options.base !== base) {
+        throw new Error(`Base ref mismatch: expected ${base}, got ${options.base}`);
+    }
+    await execAsync(`git push -u origin ${head}`, { cwd });
+    const args = ["api", "-X", "POST", `repos/${repo}/pulls`, "-f", `title=${options.title}`];
+    args.push("-f", `head=${head}`);
+    args.push("-f", `base=${normalizedBase}`);
+    if (options.body) {
+        args.push("-f", `body=${options.body}`);
+    }
+    const { stdout } = await execFileAsync("gh", args, { cwd });
+    const parsed = JSON.parse(stdout.trim());
+    if (!parsed?.url || !parsed?.number) {
+        throw new Error("GitHub CLI did not return PR url/number");
+    }
+    return { url: parsed.url, number: parsed.number };
+}
+export async function getPullRequestStatus(cwd) {
+    const lookup = await loadCurrentPullRequest(cwd);
+    return {
+        status: lookup.status,
+        githubFeaturesEnabled: lookup.githubFeaturesEnabled,
+    };
+}
+export async function getPullRequestFailureLogs(cwd) {
+    const lookup = await loadCurrentPullRequest(cwd);
+    if (!lookup.githubFeaturesEnabled) {
+        return {
+            logs: null,
+            githubFeaturesEnabled: false,
+        };
+    }
+    const failedChecks = lookup.checks.filter((check) => check.bucket === "fail" || check.bucket === "cancel");
+    if (!lookup.status || lookup.status.isMerged || failedChecks.length === 0) {
+        return {
+            logs: null,
+            githubFeaturesEnabled: true,
+        };
+    }
+    const runs = await listWorkflowRunsForHead({
+        cwd,
+        headBranch: lookup.status.headRefName,
+        headSha: lookup.headSha,
+    });
+    const matchedRuns = findRunsForFailingChecks(lookup.checks, runs);
+    const parts = [];
+    let bytes = 0;
+    bytes = appendBoundedText(parts, [
+        `PR #${lookup.status.number}: ${lookup.status.title}`,
+        `Branch: ${lookup.status.headRefName} -> ${lookup.status.baseRefName}`,
+        "",
+        "Failed required checks:",
+        ...failedChecks.map((check) => {
+            const workflowSuffix = check.workflow ? ` [${check.workflow}]` : "";
+            const descriptionSuffix = check.description ? ` - ${check.description}` : "";
+            return `- ${check.name}${workflowSuffix}${descriptionSuffix}`;
+        }),
+        "",
+    ].join("\n"), bytes);
+    if (matchedRuns.length === 0) {
+        return {
+            logs: parts.join(""),
+            githubFeaturesEnabled: true,
+        };
+    }
+    for (const run of matchedRuns) {
+        let body = "No failed-step logs were returned by GitHub CLI.";
+        try {
+            body = await getFailedWorkflowRunLog(cwd, run.databaseId);
+        }
+        catch (error) {
+            if (isGhAuthError(error)) {
+                return {
+                    logs: null,
+                    githubFeaturesEnabled: false,
+                };
+            }
+            body = error instanceof Error ? error.message : String(error);
+        }
+        const section = [
+            `=== ${run.workflowName ?? run.name ?? `Run ${run.databaseId}`} ===`,
+            run.url ? `URL: ${run.url}` : null,
+            body,
+            "",
+        ]
+            .filter((value) => Boolean(value))
+            .join("\n");
+        bytes = appendBoundedText(parts, section, bytes);
+        if (bytes >= GH_FAILED_LOG_TOTAL_MAX_BYTES) {
+            break;
+        }
+    }
+    return {
+        logs: parts.join(""),
+        githubFeaturesEnabled: true,
+    };
+}
+export async function mergePullRequest(cwd, options = {}) {
+    const method = options.method ?? "squash";
+    if (method !== "squash") {
+        throw new Error("Only squash merge is supported");
+    }
+    const statusResult = await getPullRequestStatus(cwd);
+    if (!statusResult.githubFeaturesEnabled) {
+        throw new Error("GitHub CLI (gh) is not available or not authenticated");
+    }
+    if (!statusResult.status || statusResult.status.isMerged) {
+        throw new Error("No open pull request found for current branch");
+    }
+    await execFileAsync("gh", ["pr", "merge", String(statusResult.status.number), "--squash"], {
+        cwd,
+    });
+}
 //# sourceMappingURL=checkout-git.js.map