@getpaseo/server 0.1.2

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

@@ -0,0 +1,1079 @@
+import { exec, execFile, spawn } from "child_process";
+import { promisify } from "util";
+import { resolve, dirname, basename } from "path";
+import { realpathSync } from "fs";
+import { open as openFile, stat as statFile } from "fs/promises";
+import { parseAndHighlightDiff } from "../server/utils/diff-highlighter.js";
+import { isPaseoOwnedWorktreeCwd } from "./worktree.js";
+import { requirePaseoWorktreeBaseRefName } from "./worktree-metadata.js";
+const execAsync = promisify(exec);
+const execFileAsync = promisify(execFile);
+const READ_ONLY_GIT_ENV = {
+    ...process.env,
+    GIT_OPTIONAL_LOCKS: "0",
+};
+const SMALL_OUTPUT_MAX_BUFFER = 20 * 1024 * 1024; // 20MB
+async function execGit(command, options) {
+    return execAsync(command, { ...options, maxBuffer: SMALL_OUTPUT_MAX_BUFFER });
+}
+async function spawnLimitedText(params) {
+    const accept = new Set(params.acceptExitCodes ?? [0]);
+    return new Promise((resolvePromise, rejectPromise) => {
+        const child = spawn(params.cmd, params.args, {
+            cwd: params.cwd,
+            env: params.env,
+            stdio: ["ignore", "pipe", "pipe"],
+        });
+        const stdoutChunks = [];
+        let stdoutBytes = 0;
+        let truncated = false;
+        const stop = () => {
+            if (child.killed)
+                return;
+            try {
+                child.kill("SIGKILL");
+            }
+            catch {
+                // ignore
+            }
+        };
+        child.stdout.on("data", (chunk) => {
+            if (truncated)
+                return;
+            stdoutBytes += chunk.length;
+            if (stdoutBytes > params.maxBytes) {
+                truncated = true;
+                stop();
+                return;
+            }
+            stdoutChunks.push(chunk);
+        });
+        // We don't buffer stderr (it can be large too). Keep it minimal for debugging.
+        let stderrPreview = "";
+        child.stderr.on("data", (chunk) => {
+            if (stderrPreview.length > 2048)
+                return;
+            stderrPreview += chunk.toString("utf8");
+        });
+        child.on("error", (error) => {
+            rejectPromise(error);
+        });
+        child.on("close", (code, signal) => {
+            if (code !== null && !accept.has(code) && !truncated) {
+                rejectPromise(new Error(`Command failed: ${params.cmd} ${params.args.join(" ")} (code ${code})\n${stderrPreview}`));
+                return;
+            }
+            resolvePromise({
+                text: Buffer.concat(stdoutChunks).toString("utf8"),
+                truncated,
+                exitCode: code,
+                signal,
+            });
+        });
+    });
+}
+async function listCheckoutFileChanges(cwd, ref) {
+    const changes = [];
+    const { stdout: nameStatusOut } = await execGit(`git diff --name-status ${ref}`, {
+        cwd,
+        env: READ_ONLY_GIT_ENV,
+    });
+    for (const line of nameStatusOut.split("\n").map((l) => l.trim()).filter(Boolean)) {
+        // `--name-status` uses TAB separators, which preserves filenames with spaces.
+        const tabParts = line.split("\t");
+        const rawStatus = (tabParts[0] ?? "").trim();
+        if (!rawStatus)
+            continue;
+        if (rawStatus.startsWith("R") || rawStatus.startsWith("C")) {
+            const oldPath = tabParts[1];
+            const newPath = tabParts[2];
+            if (newPath) {
+                changes.push({
+                    path: newPath,
+                    ...(oldPath ? { oldPath } : {}),
+                    status: rawStatus,
+                    isNew: false,
+                    isDeleted: false,
+                });
+            }
+            continue;
+        }
+        const path = tabParts[1];
+        if (!path)
+            continue;
+        const code = rawStatus[0];
+        changes.push({
+            path,
+            status: rawStatus,
+            isNew: code === "A",
+            isDeleted: code === "D",
+        });
+    }
+    const { stdout: untrackedOut } = await execGit("git ls-files --others --exclude-standard", {
+        cwd,
+        env: READ_ONLY_GIT_ENV,
+    });
+    for (const file of untrackedOut.split("\n").map((l) => l.trim()).filter(Boolean)) {
+        changes.push({
+            path: file,
+            status: "U",
+            isNew: true,
+            isDeleted: false,
+            isUntracked: true,
+        });
+    }
+    // Deduplicate by path (prefer tracked status over untracked marker if both appear).
+    const byPath = new Map();
+    for (const change of changes) {
+        const existing = byPath.get(change.path);
+        if (!existing) {
+            byPath.set(change.path, change);
+            continue;
+        }
+        if (existing.isUntracked && !change.isUntracked) {
+            byPath.set(change.path, change);
+        }
+    }
+    return Array.from(byPath.values());
+}
+async function tryResolveMergeBase(cwd, baseRef) {
+    try {
+        const { stdout } = await execGit(`git merge-base ${baseRef} HEAD`, { cwd, env: READ_ONLY_GIT_ENV });
+        const sha = stdout.trim();
+        return sha.length > 0 ? sha : null;
+    }
+    catch {
+        return null;
+    }
+}
+async function tryGetNumstat(cwd, args) {
+    try {
+        const { text } = await spawnLimitedText({
+            cmd: "git",
+            args,
+            cwd,
+            env: READ_ONLY_GIT_ENV,
+            maxBytes: 64 * 1024,
+            acceptExitCodes: [0],
+        });
+        const line = text.trim().split("\n").map((l) => l.trim()).filter(Boolean)[0] ?? "";
+        if (!line)
+            return null;
+        const [aRaw, dRaw] = line.split(/\s+/);
+        if (!aRaw || !dRaw)
+            return null;
+        if (aRaw === "-" || dRaw === "-") {
+            return { additions: 0, deletions: 0, isBinary: true };
+        }
+        const additions = Number.parseInt(aRaw, 10);
+        const deletions = Number.parseInt(dRaw, 10);
+        if (Number.isNaN(additions) || Number.isNaN(deletions)) {
+            return null;
+        }
+        return { additions, deletions, isBinary: false };
+    }
+    catch {
+        return null;
+    }
+}
+export class NotGitRepoError extends Error {
+    constructor(cwd) {
+        super(`Not a git repository: ${cwd}`);
+        this.code = "NOT_GIT_REPO";
+        this.name = "NotGitRepoError";
+        this.cwd = cwd;
+    }
+}
+export class MergeConflictError extends Error {
+    constructor(options) {
+        super(`Merge conflict while merging ${options.currentBranch} into ${options.baseRef}`);
+        this.name = "MergeConflictError";
+        this.baseRef = options.baseRef;
+        this.currentBranch = options.currentBranch;
+        this.conflictFiles = options.conflictFiles;
+    }
+}
+export class MergeFromBaseConflictError extends Error {
+    constructor(options) {
+        super(`Merge conflict while merging ${options.baseRef} into ${options.currentBranch}. Please merge manually.`);
+        this.name = "MergeFromBaseConflictError";
+        this.baseRef = options.baseRef;
+        this.currentBranch = options.currentBranch;
+        this.conflictFiles = options.conflictFiles;
+    }
+}
+function isGitError(error) {
+    if (!(error instanceof Error)) {
+        return false;
+    }
+    return /not a git repository/i.test(error.message) || /git repository/i.test(error.message);
+}
+async function requireGitRepo(cwd) {
+    try {
+        await execAsync("git rev-parse --git-dir", { cwd, env: READ_ONLY_GIT_ENV });
+    }
+    catch (error) {
+        throw new NotGitRepoError(cwd);
+    }
+}
+async function getCurrentBranch(cwd) {
+    const { stdout } = await execAsync("git rev-parse --abbrev-ref HEAD", {
+        cwd,
+        env: READ_ONLY_GIT_ENV,
+    });
+    const branch = stdout.trim();
+    return branch.length > 0 ? branch : null;
+}
+async function getWorktreeRoot(cwd) {
+    try {
+        const { stdout } = await execAsync("git rev-parse --path-format=absolute --show-toplevel", { cwd, env: READ_ONLY_GIT_ENV });
+        const root = stdout.trim();
+        return root.length > 0 ? root : 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();
+    const normalized = realpathSync(commonDir);
+    if (basename(normalized) === ".git") {
+        return dirname(normalized);
+    }
+    const { stdout: worktreeOut } = await execAsync("git worktree list --porcelain", {
+        cwd,
+        env: READ_ONLY_GIT_ENV,
+    });
+    const worktrees = parseWorktreeList(worktreeOut);
+    const nonBareNonPaseo = worktrees.filter((wt) => !wt.isBare && !wt.path.includes("/.paseo/worktrees/"));
+    const childrenOfBareRepo = nonBareNonPaseo.filter((wt) => wt.path.startsWith(normalized + "/"));
+    const mainChild = childrenOfBareRepo.find((wt) => basename(wt.path) === "main");
+    return mainChild?.path ?? childrenOfBareRepo[0]?.path ?? nonBareNonPaseo[0]?.path ?? normalized;
+}
+function parseWorktreeList(output) {
+    const entries = [];
+    let current = null;
+    for (const line of output.split("\n")) {
+        const trimmed = line.trim();
+        if (!trimmed) {
+            continue;
+        }
+        if (trimmed.startsWith("worktree ")) {
+            if (current) {
+                entries.push(current);
+            }
+            current = { path: trimmed.slice("worktree ".length).trim() };
+            continue;
+        }
+        if (current && trimmed.startsWith("branch ")) {
+            current.branchRef = trimmed.slice("branch ".length).trim();
+        }
+        if (current && trimmed === "bare") {
+            current.isBare = true;
+        }
+    }
+    if (current) {
+        entries.push(current);
+    }
+    return entries;
+}
+async function getWorktreePathForBranch(cwd, branchName) {
+    try {
+        const { stdout } = await execAsync("git worktree list --porcelain", {
+            cwd,
+            env: READ_ONLY_GIT_ENV,
+        });
+        const entries = parseWorktreeList(stdout);
+        const ref = branchName.startsWith("refs/heads/")
+            ? branchName
+            : `refs/heads/${branchName}`;
+        return entries.find((entry) => entry.branchRef === ref)?.path ?? null;
+    }
+    catch {
+        return null;
+    }
+}
+export async function renameCurrentBranch(cwd, newName) {
+    await requireGitRepo(cwd);
+    const previousBranch = await getCurrentBranch(cwd);
+    if (!previousBranch || previousBranch === "HEAD") {
+        throw new Error("Cannot rename branch in detached HEAD state");
+    }
+    await execAsync(`git branch -m "${newName}"`, {
+        cwd,
+    });
+    const currentBranch = await getCurrentBranch(cwd);
+    return { previousBranch, currentBranch };
+}
+async function getConfiguredBaseRefForCwd(cwd, context) {
+    // Fast-path reject: non-worktree paths do not need expensive ownership checks.
+    if (!/[\\/]worktrees[\\/]/.test(cwd)) {
+        return { baseRef: null, isPaseoOwnedWorktree: false };
+    }
+    const ownership = await isPaseoOwnedWorktreeCwd(cwd, { paseoHome: context?.paseoHome });
+    if (!ownership.allowed) {
+        return { baseRef: null, isPaseoOwnedWorktree: false };
+    }
+    const worktreeRoot = (await getWorktreeRoot(cwd)) ?? cwd;
+    return {
+        baseRef: requirePaseoWorktreeBaseRefName(worktreeRoot),
+        isPaseoOwnedWorktree: true,
+    };
+}
+async function isWorkingTreeDirty(cwd) {
+    const { stdout } = await execAsync("git status --porcelain", {
+        cwd,
+        env: READ_ONLY_GIT_ENV,
+    });
+    return stdout.trim().length > 0;
+}
+async function getOriginRemoteUrl(cwd) {
+    try {
+        const { stdout } = await execAsync("git config --get remote.origin.url", {
+            cwd,
+            env: READ_ONLY_GIT_ENV,
+        });
+        const url = stdout.trim();
+        return url.length > 0 ? url : null;
+    }
+    catch {
+        return null;
+    }
+}
+async function hasOriginRemote(cwd) {
+    const url = await getOriginRemoteUrl(cwd);
+    return url !== null;
+}
+async function resolveBaseRef(repoRoot) {
+    try {
+        const { stdout } = await execAsync("git symbolic-ref --quiet refs/remotes/origin/HEAD", {
+            cwd: repoRoot,
+            env: READ_ONLY_GIT_ENV,
+        });
+        const ref = stdout.trim();
+        if (ref) {
+            // Prefer a local branch name (e.g. "main") over the remote-tracking ref (e.g. "origin/main")
+            // so that status/diff/merge all operate against the same base ref.
+            const remoteShort = ref.replace(/^refs\/remotes\//, "");
+            const localName = remoteShort.startsWith("origin/")
+                ? remoteShort.slice("origin/".length)
+                : remoteShort;
+            try {
+                await execAsync(`git show-ref --verify --quiet refs/heads/${localName}`, {
+                    cwd: repoRoot,
+                    env: READ_ONLY_GIT_ENV,
+                });
+                return localName;
+            }
+            catch {
+                return remoteShort;
+            }
+        }
+    }
+    catch {
+        // ignore
+    }
+    const { stdout } = await execAsync("git branch --format='%(refname:short)'", {
+        cwd: repoRoot,
+        env: READ_ONLY_GIT_ENV,
+    });
+    const branches = stdout
+        .split("\n")
+        .map((line) => line.trim())
+        .filter((line) => line.length > 0);
+    if (branches.includes("main")) {
+        return "main";
+    }
+    if (branches.includes("master")) {
+        return "master";
+    }
+    return null;
+}
+function normalizeLocalBranchRefName(input) {
+    return input.startsWith("origin/") ? input.slice("origin/".length) : input;
+}
+async function doesGitRefExist(cwd, fullRef) {
+    try {
+        await execAsync(`git show-ref --verify --quiet ${fullRef}`, {
+            cwd,
+            env: READ_ONLY_GIT_ENV,
+        });
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+async function resolveBestBaseRefForMerge(cwd, normalizedBaseRef) {
+    const [hasLocal, hasOrigin] = await Promise.all([
+        doesGitRefExist(cwd, `refs/heads/${normalizedBaseRef}`),
+        doesGitRefExist(cwd, `refs/remotes/origin/${normalizedBaseRef}`),
+    ]);
+    if (hasLocal && !hasOrigin) {
+        return normalizedBaseRef;
+    }
+    if (!hasLocal && hasOrigin) {
+        return `origin/${normalizedBaseRef}`;
+    }
+    if (!hasLocal && !hasOrigin) {
+        throw new Error(`Base branch not found locally or on origin: ${normalizedBaseRef}`);
+    }
+    // Both exist: choose the ref with more unique commits compared to the other.
+    try {
+        const { stdout } = await execAsync(`git rev-list --left-right --count ${normalizedBaseRef}...origin/${normalizedBaseRef}`, { cwd, env: READ_ONLY_GIT_ENV });
+        const [localOnlyRaw, originOnlyRaw] = stdout.trim().split(/\s+/);
+        const localOnly = Number.parseInt(localOnlyRaw ?? "0", 10);
+        const originOnly = Number.parseInt(originOnlyRaw ?? "0", 10);
+        if (!Number.isNaN(localOnly) && !Number.isNaN(originOnly) && originOnly > localOnly) {
+            return `origin/${normalizedBaseRef}`;
+        }
+    }
+    catch {
+        // ignore and fall back to local
+    }
+    return normalizedBaseRef;
+}
+async function getAheadBehind(cwd, baseRef, currentBranch) {
+    const normalizedBaseRef = normalizeLocalBranchRefName(baseRef);
+    if (!normalizedBaseRef || !currentBranch || normalizedBaseRef === currentBranch) {
+        return null;
+    }
+    const { stdout } = await execAsync(`git rev-list --left-right --count ${normalizedBaseRef}...${currentBranch}`, { cwd, env: READ_ONLY_GIT_ENV });
+    const [behindRaw, aheadRaw] = stdout.trim().split(/\s+/);
+    const behind = Number.parseInt(behindRaw ?? "0", 10);
+    const ahead = Number.parseInt(aheadRaw ?? "0", 10);
+    if (Number.isNaN(behind) || Number.isNaN(ahead)) {
+        return null;
+    }
+    return { ahead, behind };
+}
+async function getAheadOfOrigin(cwd, currentBranch) {
+    if (!currentBranch) {
+        return null;
+    }
+    try {
+        const { stdout } = await execAsync(`git rev-list --count origin/${currentBranch}..${currentBranch}`, { cwd, env: READ_ONLY_GIT_ENV });
+        const count = Number.parseInt(stdout.trim(), 10);
+        return Number.isNaN(count) ? null : count;
+    }
+    catch {
+        return null;
+    }
+}
+async function inspectCheckoutContext(cwd, context) {
+    try {
+        const root = await getWorktreeRoot(cwd);
+        if (!root) {
+            return null;
+        }
+        const [currentBranch, remoteUrl, configured] = await Promise.all([
+            getCurrentBranch(cwd),
+            getOriginRemoteUrl(cwd),
+            getConfiguredBaseRefForCwd(cwd, context),
+        ]);
+        return {
+            worktreeRoot: root,
+            currentBranch,
+            remoteUrl,
+            configured,
+        };
+    }
+    catch (error) {
+        if (isGitError(error)) {
+            return null;
+        }
+        throw error;
+    }
+}
+const PER_FILE_DIFF_MAX_BYTES = 1024 * 1024; // 1MB
+const TOTAL_DIFF_MAX_BYTES = 2 * 1024 * 1024; // 2MB
+const UNTRACKED_BINARY_SNIFF_BYTES = 16 * 1024;
+async function isLikelyBinaryFile(absolutePath) {
+    const handle = await openFile(absolutePath, "r");
+    try {
+        const buffer = Buffer.allocUnsafe(UNTRACKED_BINARY_SNIFF_BYTES);
+        const { bytesRead } = await handle.read(buffer, 0, buffer.length, 0);
+        if (bytesRead === 0) {
+            return false;
+        }
+        let suspicious = 0;
+        for (let i = 0; i < bytesRead; i += 1) {
+            const byte = buffer[i];
+            if (byte === 0) {
+                return true;
+            }
+            // Treat control bytes as suspicious while allowing common whitespace.
+            if (byte < 7 || (byte > 14 && byte < 32) || byte === 127) {
+                suspicious += 1;
+            }
+        }
+        return suspicious / bytesRead > 0.3;
+    }
+    finally {
+        await handle.close();
+    }
+}
+async function inspectUntrackedFile(cwd, relativePath) {
+    const absolutePath = resolve(cwd, relativePath);
+    const metadata = await statFile(absolutePath);
+    if (!metadata.isFile()) {
+        return { stat: null, truncated: false };
+    }
+    if (await isLikelyBinaryFile(absolutePath)) {
+        return {
+            stat: { additions: 0, deletions: 0, isBinary: true },
+            truncated: false,
+        };
+    }
+    if (metadata.size > PER_FILE_DIFF_MAX_BYTES) {
+        return {
+            stat: { additions: 0, deletions: 0, isBinary: false },
+            truncated: true,
+        };
+    }
+    return {
+        stat: { additions: 0, deletions: 0, isBinary: false },
+        truncated: false,
+    };
+}
+function buildPlaceholderParsedDiffFile(change, options) {
+    return {
+        path: change.path,
+        isNew: change.isNew,
+        isDeleted: change.isDeleted,
+        additions: options.stat?.additions ?? 0,
+        deletions: options.stat?.deletions ?? 0,
+        hunks: [],
+        status: options.status,
+    };
+}
+async function getPerFileDiffText(cwd, ref, change) {
+    if (change.isUntracked) {
+        try {
+            const inspected = await inspectUntrackedFile(cwd, change.path);
+            if (inspected.stat?.isBinary || inspected.truncated) {
+                return { text: "", truncated: inspected.truncated, stat: inspected.stat };
+            }
+        }
+        catch {
+            // Fall through to git diff path if metadata probing fails.
+        }
+        const result = await spawnLimitedText({
+            cmd: "git",
+            args: ["diff", "--no-index", "/dev/null", "--", change.path],
+            cwd,
+            env: READ_ONLY_GIT_ENV,
+            maxBytes: PER_FILE_DIFF_MAX_BYTES,
+            acceptExitCodes: [0, 1],
+        });
+        return {
+            text: result.text,
+            truncated: result.truncated,
+            stat: { additions: 0, deletions: 0, isBinary: false },
+        };
+    }
+    const stat = await tryGetNumstat(cwd, ["diff", "--numstat", ref, "--", change.path]);
+    if (stat?.isBinary) {
+        return { text: "", truncated: false, stat };
+    }
+    const result = await spawnLimitedText({
+        cmd: "git",
+        args: ["diff", ref, "--", change.path],
+        cwd,
+        env: READ_ONLY_GIT_ENV,
+        maxBytes: PER_FILE_DIFF_MAX_BYTES,
+    });
+    return { text: result.text, truncated: result.truncated, stat };
+}
+export async function getCheckoutStatus(cwd, context) {
+    const inspected = await inspectCheckoutContext(cwd, context);
+    if (!inspected) {
+        return { isGit: false };
+    }
+    const worktreeRoot = inspected.worktreeRoot;
+    const currentBranch = inspected.currentBranch;
+    const remoteUrl = inspected.remoteUrl;
+    const configured = inspected.configured;
+    const isDirty = await isWorkingTreeDirty(cwd);
+    const hasRemote = remoteUrl !== null;
+    const baseRef = configured.baseRef ?? (await resolveBaseRef(cwd));
+    const aheadBehind = baseRef && currentBranch ? await getAheadBehind(cwd, baseRef, currentBranch) : null;
+    const aheadOfOrigin = hasRemote && currentBranch ? await getAheadOfOrigin(cwd, currentBranch) : null;
+    if (configured.isPaseoOwnedWorktree) {
+        const mainRepoRoot = await getMainRepoRoot(cwd);
+        return {
+            isGit: true,
+            repoRoot: worktreeRoot,
+            mainRepoRoot,
+            currentBranch,
+            isDirty,
+            baseRef: configured.baseRef,
+            aheadBehind,
+            aheadOfOrigin,
+            hasRemote,
+            remoteUrl,
+            isPaseoOwnedWorktree: true,
+        };
+    }
+    return {
+        isGit: true,
+        repoRoot: worktreeRoot,
+        currentBranch,
+        isDirty,
+        baseRef,
+        aheadBehind,
+        aheadOfOrigin,
+        hasRemote,
+        remoteUrl,
+        isPaseoOwnedWorktree: false,
+    };
+}
+export async function getCheckoutStatusLite(cwd, context) {
+    const inspected = await inspectCheckoutContext(cwd, context);
+    if (!inspected) {
+        return {
+            isGit: false,
+            currentBranch: null,
+            remoteUrl: null,
+            isPaseoOwnedWorktree: false,
+            mainRepoRoot: null,
+        };
+    }
+    if (inspected.configured.isPaseoOwnedWorktree) {
+        return {
+            isGit: true,
+            currentBranch: inspected.currentBranch,
+            remoteUrl: inspected.remoteUrl,
+            isPaseoOwnedWorktree: true,
+            mainRepoRoot: await getMainRepoRoot(cwd),
+        };
+    }
+    return {
+        isGit: true,
+        currentBranch: inspected.currentBranch,
+        remoteUrl: inspected.remoteUrl,
+        isPaseoOwnedWorktree: false,
+        mainRepoRoot: null,
+    };
+}
+export async function getCheckoutDiff(cwd, compare, context) {
+    await requireGitRepo(cwd);
+    let refForDiff;
+    if (compare.mode === "uncommitted") {
+        refForDiff = "HEAD";
+    }
+    else {
+        const configured = await getConfiguredBaseRefForCwd(cwd, context);
+        const baseRef = configured.baseRef ?? compare.baseRef ?? (await resolveBaseRef(cwd));
+        if (!baseRef) {
+            return { diff: "" };
+        }
+        if (configured.isPaseoOwnedWorktree && compare.baseRef && compare.baseRef !== baseRef) {
+            throw new Error(`Base ref mismatch: expected ${baseRef}, got ${compare.baseRef}`);
+        }
+        const normalizedBaseRef = normalizeLocalBranchRefName(baseRef);
+        const bestBaseRef = await resolveBestBaseRefForMerge(cwd, normalizedBaseRef);
+        refForDiff = (await tryResolveMergeBase(cwd, bestBaseRef)) ?? bestBaseRef;
+    }
+    const changes = await listCheckoutFileChanges(cwd, refForDiff);
+    changes.sort((a, b) => {
+        if (a.path === b.path)
+            return 0;
+        return a.path < b.path ? -1 : 1;
+    });
+    const structured = [];
+    let diffText = "";
+    let diffBytes = 0;
+    const appendDiff = (text) => {
+        if (!text)
+            return;
+        if (diffBytes >= TOTAL_DIFF_MAX_BYTES)
+            return;
+        const buf = Buffer.from(text, "utf8");
+        if (diffBytes + buf.length <= TOTAL_DIFF_MAX_BYTES) {
+            diffText += text;
+            diffBytes += buf.length;
+            return;
+        }
+        const remaining = TOTAL_DIFF_MAX_BYTES - diffBytes;
+        if (remaining > 0) {
+            diffText += buf.subarray(0, remaining).toString("utf8");
+            diffBytes = TOTAL_DIFF_MAX_BYTES;
+        }
+    };
+    for (const change of changes) {
+        const { text, truncated, stat } = await getPerFileDiffText(cwd, refForDiff, change);
+        if (!compare.includeStructured) {
+            if (stat?.isBinary) {
+                appendDiff(`# ${change.path}: binary diff omitted\n`);
+            }
+            else if (truncated) {
+                appendDiff(`# ${change.path}: diff too large omitted\n`);
+            }
+            else {
+                appendDiff(text);
+            }
+            if (diffBytes >= TOTAL_DIFF_MAX_BYTES) {
+                break;
+            }
+            continue;
+        }
+        if (stat?.isBinary) {
+            structured.push(buildPlaceholderParsedDiffFile(change, { status: "binary", stat }));
+            appendDiff(`# ${change.path}: binary diff omitted\n`);
+            continue;
+        }
+        if (truncated) {
+            structured.push(buildPlaceholderParsedDiffFile(change, { status: "too_large", stat }));
+            appendDiff(`# ${change.path}: diff too large omitted\n`);
+            continue;
+        }
+        appendDiff(text);
+        const parsed = await parseAndHighlightDiff(text, cwd);
+        const parsedFile = parsed[0] ??
+            {
+                path: change.path,
+                isNew: change.isNew,
+                isDeleted: change.isDeleted,
+                additions: stat?.additions ?? 0,
+                deletions: stat?.deletions ?? 0,
+                hunks: [],
+            };
+        structured.push({
+            ...parsedFile,
+            path: change.path,
+            isNew: change.isNew,
+            isDeleted: change.isDeleted,
+            status: "ok",
+        });
+    }
+    if (compare.includeStructured) {
+        return { diff: diffText, structured };
+    }
+    return { diff: diffText };
+}
+export async function commitChanges(cwd, options) {
+    await requireGitRepo(cwd);
+    if (options.addAll ?? true) {
+        await execFileAsync("git", ["add", "-A"], { cwd });
+    }
+    await execFileAsync("git", ["-c", "commit.gpgsign=false", "commit", "-m", options.message], {
+        cwd,
+    });
+}
+export async function commitAll(cwd, message) {
+    await commitChanges(cwd, { message, addAll: true });
+}
+export async function mergeToBase(cwd, options = {}, context) {
+    await requireGitRepo(cwd);
+    const currentBranch = await getCurrentBranch(cwd);
+    const configured = await getConfiguredBaseRefForCwd(cwd, context);
+    const baseRef = configured.baseRef ?? options.baseRef ?? (await resolveBaseRef(cwd));
+    if (!baseRef) {
+        throw new Error("Unable to determine base branch for merge");
+    }
+    if (configured.isPaseoOwnedWorktree && options.baseRef && options.baseRef !== baseRef) {
+        throw new Error(`Base ref mismatch: expected ${baseRef}, got ${options.baseRef}`);
+    }
+    if (!currentBranch) {
+        throw new Error("Unable to determine current branch for merge");
+    }
+    let normalizedBaseRef = baseRef;
+    normalizedBaseRef = normalizeLocalBranchRefName(normalizedBaseRef);
+    if (normalizedBaseRef === currentBranch) {
+        return;
+    }
+    const currentWorktreeRoot = (await getWorktreeRoot(cwd)) ?? cwd;
+    const baseWorktree = await getWorktreePathForBranch(cwd, normalizedBaseRef);
+    const operationCwd = baseWorktree ?? currentWorktreeRoot;
+    const isSameCheckout = resolve(operationCwd) === resolve(currentWorktreeRoot);
+    const originalBranch = await getCurrentBranch(operationCwd);
+    const mode = options.mode ?? "merge";
+    try {
+        await execAsync(`git checkout ${normalizedBaseRef}`, { cwd: operationCwd });
+        if (mode === "squash") {
+            await execAsync(`git merge --squash ${currentBranch}`, { cwd: operationCwd });
+            const message = options.commitMessage ?? `Squash merge ${currentBranch} into ${normalizedBaseRef}`;
+            await execFileAsync("git", ["-c", "commit.gpgsign=false", "commit", "-m", message], { cwd: operationCwd });
+        }
+        else {
+            await execAsync(`git merge ${currentBranch}`, { cwd: operationCwd });
+        }
+    }
+    catch (error) {
+        const errorDetails = error instanceof Error
+            ? `${error.message}\n${error.stderr ?? ""}\n${error.stdout ?? ""}`
+            : String(error);
+        try {
+            const [unmergedOutput, lsFilesOutput, statusOutput] = await Promise.all([
+                execAsync("git diff --name-only --diff-filter=U", { cwd: operationCwd }),
+                execAsync("git ls-files -u", { cwd: operationCwd }),
+                execAsync("git status --porcelain", { cwd: operationCwd }),
+            ]);
+            const statusConflicts = statusOutput.stdout
+                .split("\n")
+                .map((line) => line.trim())
+                .filter(Boolean)
+                .filter((line) => /^(UU|AA|DD|AU|UA|UD|DU)\s/.test(line))
+                .map((line) => line.slice(3).trim());
+            const conflicts = [
+                ...unmergedOutput.stdout
+                    .split("\n")
+                    .map((line) => line.trim())
+                    .filter(Boolean),
+                ...lsFilesOutput.stdout
+                    .split("\n")
+                    .map((line) => line.trim())
+                    .filter(Boolean)
+                    .map((line) => line.split("\t").pop()),
+                ...statusConflicts,
+            ].filter(Boolean);
+            const conflictDetected = conflicts.length > 0 || /CONFLICT|Automatic merge failed/i.test(errorDetails);
+            if (conflictDetected) {
+                try {
+                    await execAsync("git merge --abort", { cwd: operationCwd });
+                }
+                catch {
+                    // ignore
+                }
+                throw new MergeConflictError({
+                    baseRef: normalizedBaseRef,
+                    currentBranch,
+                    conflictFiles: conflicts.length > 0 ? conflicts : [],
+                });
+            }
+        }
+        catch (innerError) {
+            if (innerError instanceof MergeConflictError) {
+                throw innerError;
+            }
+            // ignore detection failures
+        }
+        throw error;
+    }
+    finally {
+        if (isSameCheckout && originalBranch && originalBranch !== normalizedBaseRef) {
+            try {
+                await execAsync(`git checkout ${originalBranch}`, { cwd: operationCwd });
+            }
+            catch {
+                // ignore
+            }
+        }
+    }
+}
+export async function mergeFromBase(cwd, options = {}, context) {
+    await requireGitRepo(cwd);
+    const currentBranch = await getCurrentBranch(cwd);
+    if (!currentBranch || currentBranch === "HEAD") {
+        throw new Error("Unable to determine current branch for merge");
+    }
+    const configured = await getConfiguredBaseRefForCwd(cwd, context);
+    const baseRef = configured.baseRef ?? options.baseRef ?? (await resolveBaseRef(cwd));
+    if (!baseRef) {
+        throw new Error("Unable to determine base branch for merge");
+    }
+    if (configured.isPaseoOwnedWorktree && options.baseRef && options.baseRef !== baseRef) {
+        throw new Error(`Base ref mismatch: expected ${baseRef}, got ${options.baseRef}`);
+    }
+    const requireCleanTarget = options.requireCleanTarget ?? true;
+    if (requireCleanTarget) {
+        const { stdout } = await execAsync("git status --porcelain", {
+            cwd,
+            env: READ_ONLY_GIT_ENV,
+        });
+        if (stdout.trim().length > 0) {
+            throw new Error("Working directory has uncommitted changes.");
+        }
+    }
+    const normalizedBaseRef = normalizeLocalBranchRefName(baseRef);
+    const bestBaseRef = await resolveBestBaseRefForMerge(cwd, normalizedBaseRef);
+    if (bestBaseRef === currentBranch) {
+        return;
+    }
+    try {
+        await execAsync(`git merge ${bestBaseRef}`, { cwd });
+    }
+    catch (error) {
+        const errorDetails = error instanceof Error
+            ? `${error.message}\n${error.stderr ?? ""}\n${error.stdout ?? ""}`
+            : String(error);
+        try {
+            const [unmergedOutput, lsFilesOutput, statusOutput] = await Promise.all([
+                execAsync("git diff --name-only --diff-filter=U", { cwd }),
+                execAsync("git ls-files -u", { cwd }),
+                execAsync("git status --porcelain", { cwd }),
+            ]);
+            const statusConflicts = statusOutput.stdout
+                .split("\n")
+                .map((line) => line.trim())
+                .filter(Boolean)
+                .filter((line) => /^(UU|AA|DD|AU|UA|UD|DU)\s/.test(line))
+                .map((line) => line.slice(3).trim());
+            const conflicts = [
+                ...unmergedOutput.stdout
+                    .split("\n")
+                    .map((line) => line.trim())
+                    .filter(Boolean),
+                ...lsFilesOutput.stdout
+                    .split("\n")
+                    .map((line) => line.trim())
+                    .filter(Boolean)
+                    .map((line) => line.split("\t").pop()),
+                ...statusConflicts,
+            ].filter(Boolean);
+            const conflictDetected = conflicts.length > 0 || /CONFLICT|Automatic merge failed/i.test(errorDetails);
+            if (conflictDetected) {
+                try {
+                    await execAsync("git merge --abort", { cwd });
+                }
+                catch {
+                    // ignore
+                }
+                throw new MergeFromBaseConflictError({
+                    baseRef: bestBaseRef,
+                    currentBranch,
+                    conflictFiles: conflicts.length > 0 ? conflicts : [],
+                });
+            }
+        }
+        catch (innerError) {
+            if (innerError instanceof MergeFromBaseConflictError) {
+                throw innerError;
+            }
+            // ignore detection failures
+        }
+        throw error;
+    }
+}
+export async function pushCurrentBranch(cwd) {
+    await requireGitRepo(cwd);
+    const currentBranch = await getCurrentBranch(cwd);
+    if (!currentBranch || currentBranch === "HEAD") {
+        throw new Error("Unable to determine current branch for push");
+    }
+    const hasRemote = await hasOriginRemote(cwd);
+    if (!hasRemote) {
+        throw new Error("Remote 'origin' is not configured.");
+    }
+    await execAsync(`git push -u origin ${currentBranch}`, { cwd });
+}
+async function ensureGhAvailable(cwd) {
+    try {
+        await execAsync("gh --version", { cwd });
+    }
+    catch {
+        throw new Error("GitHub CLI (gh) is not available or not authenticated");
+    }
+}
+async function resolveGitHubRepo(cwd) {
+    try {
+        const { stdout } = await execAsync("git config --get remote.origin.url", {
+            cwd,
+            env: READ_ONLY_GIT_ENV,
+        });
+        const url = stdout.trim();
+        if (!url) {
+            return null;
+        }
+        let cleaned = url;
+        if (cleaned.startsWith("git@github.com:")) {
+            cleaned = cleaned.slice("git@github.com:".length);
+        }
+        else if (cleaned.startsWith("https://github.com/")) {
+            cleaned = cleaned.slice("https://github.com/".length);
+        }
+        else if (cleaned.startsWith("http://github.com/")) {
+            cleaned = cleaned.slice("http://github.com/".length);
+        }
+        else {
+            const marker = "github.com/";
+            const index = cleaned.indexOf(marker);
+            if (index !== -1) {
+                cleaned = cleaned.slice(index + marker.length);
+            }
+            else {
+                return null;
+            }
+        }
+        if (cleaned.endsWith(".git")) {
+            cleaned = cleaned.slice(0, -".git".length);
+        }
+        if (!cleaned.includes("/")) {
+            return null;
+        }
+        return cleaned;
+    }
+    catch {
+        // ignore
+    }
+    return 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");
+    }
+    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.isPaseoOwnedWorktree && 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) {
+    await requireGitRepo(cwd);
+    await ensureGhAvailable(cwd);
+    const repo = await resolveGitHubRepo(cwd);
+    const head = await getCurrentBranch(cwd);
+    if (!repo || !head) {
+        return null;
+    }
+    const owner = repo.split("/")[0];
+    const { stdout } = await execFileAsync("gh", [
+        "api",
+        `repos/${repo}/pulls`,
+        "-X",
+        "GET",
+        "-F",
+        `head=${owner}:${head}`,
+        "-F",
+        "state=open",
+    ], { cwd });
+    const parsed = JSON.parse(stdout.trim());
+    const current = Array.isArray(parsed) && parsed.length > 0 ? parsed[0] : null;
+    if (!current) {
+        return null;
+    }
+    return {
+        url: current.html_url ?? current.url,
+        title: current.title,
+        state: current.state,
+        baseRefName: current.base?.ref ?? "",
+        headRefName: current.head?.ref ?? head,
+    };
+}
+//# sourceMappingURL=checkout-git.js.map