@getforgeai/cli 0.1.0-beta.1

package/dist/lib/branch-manager.js

@@ -0,0 +1,620 @@
+import { execFile } from "node:child_process";
+import { existsSync, statSync } from "node:fs";
+import { promisify } from "node:util";
+import chalk from "chalk";
+import { Mutex } from "async-mutex";
+import { homedir } from "node:os";
+import { join } from "node:path";
+/**
+ * Resolve the local repo path for a project.
+ * Clone if missing, fetch if existing. Used for branch operations on the host
+ * (listing branches, creating workflow branches) before a VM is booted.
+ */
+async function resolveRepoPath(projectSlug, repoUrl) {
+    if (!repoUrl) {
+        console.warn(chalk.yellow("[branch] No repoUrl provided, falling back to process.cwd()"));
+        return process.cwd();
+    }
+    const VALID_GIT_URL = /^(https?:\/\/[\w.-]+\w(\/|$)|git@\w[\w.-]*:)/;
+    const targetDir = join(homedir(), ".forgeai", "repos", projectSlug);
+    const mutex = getRepoMutex(targetDir);
+    return mutex.runExclusive(async () => {
+        const gitPath = join(targetDir, ".git");
+        const repoExists = existsSync(gitPath) && statSync(gitPath).isDirectory();
+        if (repoExists) {
+            try {
+                await execFileAsync("git", ["fetch", "--all"], {
+                    cwd: targetDir,
+                    timeout: 60_000,
+                });
+            }
+            catch {
+                // Non-fatal fetch failure
+            }
+        }
+        else {
+            if (!VALID_GIT_URL.test(repoUrl)) {
+                throw new Error(`Invalid git URL format: ${repoUrl}`);
+            }
+            await execFileAsync("git", ["clone", repoUrl, targetDir], {
+                timeout: 120_000,
+            });
+        }
+        return targetDir;
+    });
+}
+const execFileAsync = promisify(execFile);
+// Per-repo mutex to serialize git worktree operations (AC: #6)
+const repoMutexes = new Map();
+function getRepoMutex(repoPath) {
+    let mutex = repoMutexes.get(repoPath);
+    if (!mutex) {
+        mutex = new Mutex();
+        repoMutexes.set(repoPath, mutex);
+    }
+    return mutex;
+}
+function getProjectSlugOrDefault(payload) {
+    if (!payload.projectSlug) {
+        console.error(chalk.red('[branch] Missing projectSlug in payload, using "default" — this WILL cause repo path conflicts if multiple projects are active. Ensure Cloud sends projectSlug in all event payloads.'));
+        return "default";
+    }
+    return payload.projectSlug;
+}
+/**
+ * Check if a repository has zero commits (freshly created / empty).
+ */
+async function isRepoEmpty(repoPath) {
+    try {
+        await execFileAsync("git", ["rev-parse", "HEAD"], { cwd: repoPath });
+        return false;
+    }
+    catch {
+        return true;
+    }
+}
+/**
+ * Initialize an empty repository with an initial commit and push the source branch.
+ * Used for greenfield projects where the remote repo was just created (no commits).
+ *
+ * Must be called inside the repo mutex (callers already hold it).
+ */
+async function initializeSourceBranch(repoPath, sourceBranch) {
+    try {
+        // Create an initial empty commit
+        await execFileAsync("git", ["commit", "--allow-empty", "-m", "Initial commit"], { cwd: repoPath });
+        // Ensure we're on the expected source branch name
+        const { stdout: currentBranch } = await execFileAsync("git", ["rev-parse", "--abbrev-ref", "HEAD"], { cwd: repoPath });
+        if (currentBranch.trim() !== sourceBranch) {
+            await execFileAsync("git", ["branch", "-M", sourceBranch], {
+                cwd: repoPath,
+            });
+        }
+        // Push the source branch to remote
+        await execFileAsync("git", ["push", "-u", "origin", sourceBranch], {
+            cwd: repoPath,
+        });
+        console.log(chalk.green(`[branch] Initialized empty repo: created and pushed "${sourceBranch}"`));
+        return { success: true };
+    }
+    catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        console.error(chalk.red(`[branch] Failed to initialize empty repo: ${message}`));
+        return { success: false, error: message };
+    }
+}
+/**
+ * List remote branches for a git repository at the given path.
+ * Returns branch names (short format, without origin/ prefix) and the default branch.
+ */
+export async function listBranches(repoPath) {
+    const { stdout: branchOutput } = await execFileAsync("git", ["branch", "-r", "--format=%(refname:short)"], { cwd: repoPath });
+    const branches = branchOutput
+        .split("\n")
+        .map((b) => b.trim())
+        .filter((b) => b.length > 0 && !b.includes("HEAD"))
+        .map((b) => b.replace(/^origin\//, ""));
+    let defaultBranch = "main";
+    try {
+        const { stdout: headRef } = await execFileAsync("git", ["symbolic-ref", "refs/remotes/origin/HEAD"], { cwd: repoPath });
+        const ref = headRef.trim();
+        // refs/remotes/origin/main → main
+        const match = /refs\/remotes\/origin\/(.+)/.exec(ref);
+        if (match?.[1]) {
+            defaultBranch = match[1];
+        }
+    }
+    catch {
+        // Fallback: if HEAD ref is not set, try to detect main/master
+        if (branches.includes("main")) {
+            defaultBranch = "main";
+        }
+        else if (branches.includes("master")) {
+            defaultBranch = "master";
+        }
+        else if (branches.length > 0) {
+            defaultBranch = branches[0];
+        }
+    }
+    return { branches, defaultBranch };
+}
+/**
+ * Create a workflow branch from a source branch.
+ * Idempotent: if the branch already exists from the same source, reports success.
+ *
+ * Steps:
+ * 1. Fetch the latest source branch from remote (ensures it's up-to-date)
+ * 2. Create the workflow branch from `origin/<sourceBranch>`
+ * 3. Push the workflow branch to remote with tracking (`-u`)
+ */
+export async function createWorkflowBranch(repoPath, sourceBranch, baseBranch) {
+    const mutex = getRepoMutex(repoPath);
+    return mutex.runExclusive(async () => {
+        try {
+            // Check if branch already exists
+            try {
+                const { stdout } = await execFileAsync("git", ["rev-parse", "--verify", baseBranch], { cwd: repoPath });
+                if (stdout.trim()) {
+                    // Branch exists — check if it was created from the same source
+                    const { stdout: baseCommit } = await execFileAsync("git", ["merge-base", baseBranch, sourceBranch], { cwd: repoPath });
+                    const { stdout: sourceHead } = await execFileAsync("git", ["rev-parse", sourceBranch], { cwd: repoPath });
+                    // If merge-base equals source HEAD, the branch was created from this source
+                    if (baseCommit.trim() === sourceHead.trim()) {
+                        console.log(chalk.green(`[branch] Branch "${baseBranch}" already exists from "${sourceBranch}" — idempotent success`));
+                        return { success: true };
+                    }
+                    return {
+                        success: false,
+                        error: `Branch "${baseBranch}" already exists but was not created from "${sourceBranch}"`,
+                    };
+                }
+            }
+            catch {
+                // Branch doesn't exist — this is the expected path, continue to create
+            }
+            // Fetch latest source branch from remote to ensure we branch
+            // from the most recent state
+            let baseRef = sourceBranch;
+            try {
+                await execFileAsync("git", ["fetch", "origin", sourceBranch], {
+                    cwd: repoPath,
+                });
+                baseRef = `origin/${sourceBranch}`;
+                console.log(chalk.blue(`[branch] Fetched latest "${sourceBranch}" from remote`));
+            }
+            catch {
+                // Source branch not on remote — check if repo is empty (greenfield)
+                if (await isRepoEmpty(repoPath)) {
+                    console.log(chalk.cyan(`[branch] Empty repo detected — initializing with branch "${sourceBranch}"`));
+                    const initResult = await initializeSourceBranch(repoPath, sourceBranch);
+                    if (!initResult.success) {
+                        return {
+                            success: false,
+                            error: `Failed to initialize empty repo: ${initResult.error}`,
+                        };
+                    }
+                    // After init, sourceBranch exists locally — baseRef is already set
+                }
+                else {
+                    console.log(chalk.yellow(`[branch] Could not fetch "${sourceBranch}" from remote, using local ref`));
+                }
+            }
+            // Create the branch
+            await execFileAsync("git", ["branch", baseBranch, baseRef], {
+                cwd: repoPath,
+            });
+            console.log(chalk.green(`[branch] Created "${baseBranch}" from "${baseRef}"`));
+            // Push workflow branch to remote with tracking
+            try {
+                await execFileAsync("git", ["push", "-u", "origin", baseBranch], {
+                    cwd: repoPath,
+                });
+                console.log(chalk.green(`[branch] Pushed "${baseBranch}" to remote`));
+            }
+            catch (error_) {
+                const msg = error_ instanceof Error ? error_.message : String(error_);
+                console.warn(chalk.yellow(`[branch] Failed to push "${baseBranch}" to remote: ${msg} — branch exists locally`));
+                // Non-fatal: branch exists locally, can be pushed later
+            }
+            return { success: true };
+        }
+        catch (error) {
+            const message = error instanceof Error ? error.message : String(error);
+            console.error(chalk.red(`[branch] Failed to create branch: ${message}`));
+            return { success: false, error: message };
+        }
+    });
+}
+/**
+ * Normalize a git remote URL for comparison.
+ * Handles https, ssh, and .git suffix differences.
+ */
+export function normalizeRepoUrl(url) {
+    return url
+        .replace(/\.git$/, "")
+        .replace(/^git@([^:]+):/, "https://$1/")
+        .replace(/\/$/, "")
+        .toLowerCase();
+}
+/**
+ * Verify the local repo's origin URL matches the expected URL.
+ * Returns null on match, or an error message on mismatch.
+ */
+async function verifyRepoUrl(repoPath, expectedUrl) {
+    try {
+        const { stdout } = await execFileAsync("git", ["remote", "get-url", "origin"], { cwd: repoPath });
+        const localUrl = stdout.trim();
+        if (normalizeRepoUrl(localUrl) !== normalizeRepoUrl(expectedUrl)) {
+            return `Repo URL mismatch: local="${localUrl}", expected="${expectedUrl}"`;
+        }
+        return null;
+    }
+    catch {
+        return "Could not determine local repo origin URL";
+    }
+}
+// --- PR operations (Story 5c.3) ---
+/**
+ * Check if the GitHub CLI (gh) is installed and authenticated.
+ */
+export async function checkGhCliAvailable() {
+    try {
+        await execFileAsync("gh", ["auth", "status"]);
+        return { available: true };
+    }
+    catch {
+        return {
+            available: false,
+            error: "GitHub CLI (gh) not installed or not authenticated. Run 'gh auth login'.",
+        };
+    }
+}
+/**
+ * Delete a local branch.
+ * Uses per-repo mutex to prevent concurrent branch operations.
+ */
+async function deleteLocalBranch(repoPath, branchName) {
+    const mutex = getRepoMutex(repoPath);
+    return mutex.runExclusive(async () => {
+        try {
+            // Check if branch exists
+            try {
+                await execFileAsync("git", ["rev-parse", "--verify", branchName], {
+                    cwd: repoPath,
+                });
+            }
+            catch {
+                console.log(chalk.yellow(`[merge] Local branch "${branchName}" does not exist — already cleaned`));
+                return { success: true };
+            }
+            await execFileAsync("git", ["branch", "-D", branchName], {
+                cwd: repoPath,
+            });
+            console.log(chalk.green(`[merge] Deleted local branch "${branchName}"`));
+            return { success: true };
+        }
+        catch (error) {
+            const message = error instanceof Error ? error.message : String(error);
+            console.error(chalk.red(`[merge] Failed to delete local branch: ${message}`));
+            return { success: false, error: message };
+        }
+    });
+}
+// --- Worktree operations (Story 5c.2) ---
+/**
+ * Create a task branch from a workflow base branch and push it to remote.
+ * Idempotent: if the branch already exists, reports success.
+ *
+ * Steps:
+ * 1. Fetch the latest workflow base branch from remote (ensures it's up-to-date)
+ * 2. Create the task branch from `origin/<workflowBaseBranch>`
+ * 3. Push the task branch to remote with tracking (`-u`)
+ */
+/** Check if a git branch already exists (idempotent guard). Returns true if it exists. */
+async function branchExists(repoPath, branch) {
+    try {
+        const { stdout } = await execFileAsync("git", ["rev-parse", "--verify", branch], { cwd: repoPath });
+        if (stdout.trim()) {
+            console.log(chalk.green(`[worktree] Task branch "${branch}" already exists — idempotent success`));
+            return true;
+        }
+    }
+    catch {
+        // Branch doesn't exist — expected path
+    }
+    return false;
+}
+/** Push a branch to remote with tracking (non-fatal on failure). */
+async function pushBranchToRemote(repoPath, branch) {
+    try {
+        await execFileAsync("git", ["push", "-u", "origin", branch], {
+            cwd: repoPath,
+        });
+        console.log(chalk.green(`[worktree] Pushed task branch "${branch}" to remote`));
+    }
+    catch (error_) {
+        const msg = error_ instanceof Error ? error_.message : String(error_);
+        console.warn(chalk.yellow(`[worktree] Failed to push task branch "${branch}": ${msg} — agent can push later`));
+    }
+}
+export async function createTaskBranch(repoPath, workflowBaseBranch, taskBranch) {
+    const mutex = getRepoMutex(repoPath);
+    return mutex.runExclusive(async () => {
+        try {
+            if (await branchExists(repoPath, taskBranch)) {
+                return { success: true };
+            }
+            // Fetch latest workflow base branch from remote to ensure we branch
+            // from the most recent state (other agents may have pushed commits)
+            let baseRef = workflowBaseBranch;
+            try {
+                await execFileAsync("git", ["fetch", "origin", workflowBaseBranch], {
+                    cwd: repoPath,
+                });
+                baseRef = `origin/${workflowBaseBranch}`;
+                console.log(chalk.blue(`[worktree] Fetched latest "${workflowBaseBranch}" from remote`));
+            }
+            catch {
+                console.log(chalk.yellow(`[worktree] Could not fetch "${workflowBaseBranch}" from remote, using local ref`));
+            }
+            await execFileAsync("git", ["branch", taskBranch, baseRef], {
+                cwd: repoPath,
+            });
+            console.log(chalk.green(`[worktree] Created task branch "${taskBranch}" from "${baseRef}"`));
+            await pushBranchToRemote(repoPath, taskBranch);
+            return { success: true };
+        }
+        catch (error) {
+            const message = error instanceof Error ? error.message : String(error);
+            console.error(chalk.red(`[worktree] Failed to create task branch: ${message}`));
+            return { success: false, error: message };
+        }
+    });
+}
+/**
+ * Create a task branch from HEAD (fallback for non-workflow tasks).
+ * Idempotent: if the branch already exists, reports success.
+ *
+ * Used when a task is dispatched without a workflow base branch,
+ * providing worktree isolation even for standalone tasks.
+ */
+export async function createTaskBranchFromHead(repoPath, taskBranch) {
+    const mutex = getRepoMutex(repoPath);
+    return mutex.runExclusive(async () => {
+        try {
+            if (await branchExists(repoPath, taskBranch)) {
+                return { success: true };
+            }
+            await execFileAsync("git", ["branch", taskBranch, "HEAD"], {
+                cwd: repoPath,
+            });
+            console.log(chalk.green(`[worktree] Created task branch "${taskBranch}" from HEAD (no workflow branch)`));
+            await pushBranchToRemote(repoPath, taskBranch);
+            return { success: true };
+        }
+        catch (error) {
+            const message = error instanceof Error ? error.message : String(error);
+            console.error(chalk.red(`[worktree] Failed to create task branch from HEAD: ${message}`));
+            return { success: false, error: message };
+        }
+    });
+}
+/**
+ * Ensure all changes in a repository are committed and pushed.
+ * Best-effort safety net: auto-commits dirty working tree and pushes unpushed commits.
+ * Uses per-repo mutex to prevent race conditions between concurrent callers.
+ */
+export async function ensureChangesCommittedAndPushed(repoPath, commitMessage) {
+    const mutex = getRepoMutex(repoPath);
+    return mutex.runExclusive(async () => {
+        let committed = false;
+        let pushed = false;
+        try {
+            // Verify path exists and is a git directory
+            if (!existsSync(repoPath)) {
+                return {
+                    committed,
+                    pushed,
+                    error: `Path does not exist: ${repoPath}`,
+                };
+            }
+            // 1. Check for uncommitted changes
+            const { stdout: status } = await execFileAsync("git", ["status", "--porcelain"], { cwd: repoPath });
+            if (status.trim()) {
+                // Dirty working tree — auto-commit
+                await execFileAsync("git", ["add", "-A"], { cwd: repoPath });
+                await execFileAsync("git", ["commit", "-m", commitMessage], {
+                    cwd: repoPath,
+                });
+                committed = true;
+                console.log(chalk.green(`[guard] Auto-committed changes in ${repoPath}`));
+            }
+            // 2. Push any unpushed commits
+            // First try with upstream tracking, fall back to explicit push if no upstream
+            try {
+                const { stdout: unpushedLog } = await execFileAsync("git", ["log", "@{upstream}..HEAD", "--oneline"], { cwd: repoPath });
+                if (unpushedLog.trim()) {
+                    await execFileAsync("git", ["push"], { cwd: repoPath });
+                    pushed = true;
+                    console.log(chalk.green(`[guard] Auto-pushed commits from ${repoPath}`));
+                }
+            }
+            catch {
+                // No upstream configured — detect current branch and push with --set-upstream
+                try {
+                    const { stdout: branchOutput } = await execFileAsync("git", ["rev-parse", "--abbrev-ref", "HEAD"], { cwd: repoPath });
+                    const currentBranch = branchOutput.trim();
+                    if (currentBranch && currentBranch !== "HEAD") {
+                        await execFileAsync("git", ["push", "--set-upstream", "origin", currentBranch], { cwd: repoPath });
+                        pushed = true;
+                        console.log(chalk.green(`[guard] Auto-pushed and set upstream for "${currentBranch}" from ${repoPath}`));
+                    }
+                }
+                catch (error_) {
+                    const msg = error_ instanceof Error ? error_.message : String(error_);
+                    console.warn(chalk.yellow(`[guard] Failed to push from ${repoPath}: ${msg}`));
+                    return { committed, pushed, error: `Push failed: ${msg}` };
+                }
+            }
+            return { committed, pushed };
+        }
+        catch (error) {
+            const message = error instanceof Error ? error.message : String(error);
+            console.error(chalk.red(`[guard] Failed to ensure changes committed/pushed: ${message}`));
+            return { committed, pushed, error: message };
+        }
+    });
+}
+/**
+ * Ensure a workflow branch exists locally.
+ * Handles 3 scenarios (in order), using per-repo mutex:
+ * 1. Branch exists locally → pull latest from remote (fast-forward)
+ * 2. Branch only on remote → fetch + create local tracking branch
+ * 3. Branch doesn't exist anywhere → create from sourceBranch
+ */
+export async function ensureWorkflowBranch(repoPath, baseBranch, sourceBranch) {
+    const mutex = getRepoMutex(repoPath);
+    return mutex.runExclusive(async () => {
+        try {
+            // 1. Check if branch exists locally
+            try {
+                const { stdout } = await execFileAsync("git", ["rev-parse", "--verify", baseBranch], { cwd: repoPath });
+                if (stdout.trim()) {
+                    console.log(chalk.green(`[worktree] Workflow branch "${baseBranch}" already exists locally — idempotent success`));
+                    // Branch exists locally — update to latest remote state
+                    // Uses `git branch -f` instead of `git merge` to avoid affecting the
+                    // currently checked-out branch in the main repo
+                    try {
+                        await execFileAsync("git", ["fetch", "origin", baseBranch], {
+                            cwd: repoPath,
+                        });
+                        await execFileAsync("git", ["branch", "-f", baseBranch, `origin/${baseBranch}`], { cwd: repoPath });
+                        console.log(chalk.blue(`[branch] Updated "${baseBranch}" to latest remote state`));
+                    }
+                    catch {
+                        // Remote may not have the branch yet (first workflow step) — that's OK
+                        console.log(chalk.yellow(`[branch] Could not update "${baseBranch}" from remote, using local state`));
+                    }
+                    return { success: true };
+                }
+            }
+            catch {
+                // Branch doesn't exist locally — continue
+            }
+            // 2. Check if branch exists on remote → fetch + create local branch
+            try {
+                await execFileAsync("git", ["fetch", "origin", baseBranch], {
+                    cwd: repoPath,
+                });
+                // Fetch succeeded — create local branch from remote
+                await execFileAsync("git", ["branch", baseBranch, `origin/${baseBranch}`], { cwd: repoPath });
+                console.log(chalk.green(`[worktree] Fetched and created local branch "${baseBranch}" from remote`));
+                return { success: true };
+            }
+            catch {
+                // Branch not on remote either — continue to create from source
+            }
+            // 3. Branch doesn't exist anywhere — create from sourceBranch
+            // If repo is empty (no commits), initialize with the source branch first
+            if (await isRepoEmpty(repoPath)) {
+                console.log(chalk.cyan(`[worktree] Empty repo detected — initializing with branch "${sourceBranch}"`));
+                const initResult = await initializeSourceBranch(repoPath, sourceBranch);
+                if (!initResult.success) {
+                    return {
+                        success: false,
+                        error: `Failed to initialize empty repo: ${initResult.error}`,
+                    };
+                }
+            }
+            await execFileAsync("git", ["branch", baseBranch, sourceBranch], {
+                cwd: repoPath,
+            });
+            console.log(chalk.green(`[worktree] Created workflow branch "${baseBranch}" from "${sourceBranch}"`));
+            return { success: true };
+        }
+        catch (error) {
+            const message = error instanceof Error ? error.message : String(error);
+            console.error(chalk.red(`[worktree] Failed to ensure workflow branch: ${message}`));
+            return { success: false, error: message };
+        }
+    });
+}
+/**
+ * Register branch-related Socket.io event handlers on a CLI socket.
+ * Handles branch listing and branch creation requests from Cloud.
+ */
+export function registerBranchHandlers(socket, orgId) {
+    socket.on("workflow:branch:list:request", async (payload) => {
+        try {
+            const repoPath = await resolveRepoPath(getProjectSlugOrDefault(payload), payload.repoUrl);
+            // Verify repo URL matches before listing
+            const mismatch = await verifyRepoUrl(repoPath, payload.repoUrl);
+            if (mismatch) {
+                console.warn(chalk.yellow(`[branch] ${mismatch} — skipping list`));
+                return;
+            }
+            const result = await listBranches(repoPath);
+            socket.emit("workflow:branch:list:response", {
+                orgId,
+                projectId: payload.projectId,
+                branches: result.branches,
+                defaultBranch: result.defaultBranch,
+                timestamp: new Date().toISOString(),
+            });
+            console.log(chalk.green(`[branch] Listed ${result.branches.length} branches (default: ${result.defaultBranch})`));
+        }
+        catch (error) {
+            const message = error instanceof Error ? error.message : String(error);
+            console.error(chalk.red(`[branch] Failed to list branches: ${message}`));
+            // Send empty response so UI can fall back to text input
+            socket.emit("workflow:branch:list:response", {
+                orgId,
+                projectId: payload.projectId,
+                branches: [],
+                defaultBranch: "main",
+                timestamp: new Date().toISOString(),
+            });
+        }
+    });
+    socket.on("workflow:branch:create", async (payload) => {
+        try {
+            const repoPath = await resolveRepoPath(getProjectSlugOrDefault(payload), payload.repoUrl);
+            // Verify repo URL matches before creating branch
+            const mismatch = await verifyRepoUrl(repoPath, payload.repoUrl);
+            if (mismatch) {
+                console.warn(chalk.yellow(`[branch] ${mismatch}`));
+                socket.emit("workflow:branch:created", {
+                    orgId,
+                    workflowId: payload.workflowId,
+                    baseBranch: payload.baseBranch,
+                    success: false,
+                    error: mismatch,
+                    timestamp: new Date().toISOString(),
+                });
+                return;
+            }
+            const result = await createWorkflowBranch(repoPath, payload.sourceBranch, payload.baseBranch);
+            socket.emit("workflow:branch:created", {
+                orgId,
+                workflowId: payload.workflowId,
+                baseBranch: payload.baseBranch,
+                success: result.success,
+                error: result.error,
+                timestamp: new Date().toISOString(),
+            });
+        }
+        catch (error) {
+            const message = error instanceof Error ? error.message : String(error);
+            console.error(chalk.red(`[branch] Unexpected error creating branch: ${message}`));
+            socket.emit("workflow:branch:created", {
+                orgId,
+                workflowId: payload.workflowId,
+                baseBranch: payload.baseBranch,
+                success: false,
+                error: message,
+                timestamp: new Date().toISOString(),
+            });
+        }
+    });
+}
+//# sourceMappingURL=branch-manager.js.map

package/dist/lib/clone-and-checkout.d.ts

@@ -0,0 +1,6 @@
+/**
+ * Clone a repo and checkout a specific branch, or fetch + checkout if already cloned.
+ * Target directory: ~/.forgeai/open/<projectSlug>/<branchSlug>/
+ */
+export declare function cloneAndCheckout(repoUrl: string, branch: string, targetDir: string): Promise<void>;
+//# sourceMappingURL=clone-and-checkout.d.ts.map

package/dist/lib/clone-and-checkout.js

@@ -0,0 +1,41 @@
+import { existsSync } from "node:fs";
+import { mkdir } from "node:fs/promises";
+import { join, dirname } from "node:path";
+import { execFile } from "node:child_process";
+import { promisify } from "node:util";
+import chalk from "chalk";
+const execFileAsync = promisify(execFile);
+/**
+ * Clone a repo and checkout a specific branch, or fetch + checkout if already cloned.
+ * Target directory: ~/.forgeai/open/<projectSlug>/<branchSlug>/
+ */
+export async function cloneAndCheckout(repoUrl, branch, targetDir) {
+    const gitDir = join(targetDir, ".git");
+    if (existsSync(gitDir)) {
+        // Already cloned — fetch and checkout
+        console.log(chalk.dim(`[open] Fetching latest changes in ${targetDir}`));
+        await execFileAsync("git", ["fetch", "--all"], { cwd: targetDir });
+        await execFileAsync("git", ["checkout", branch], { cwd: targetDir }).catch(async () => {
+            // Branch might be remote-only
+            await execFileAsync("git", ["checkout", "-b", branch, `origin/${branch}`], { cwd: targetDir });
+        });
+        await execFileAsync("git", ["pull", "--ff-only"], { cwd: targetDir }).catch(() => {
+            // Pull may fail if detached or diverged — non-fatal
+        });
+        console.log(chalk.green(`[open] Checked out ${branch}`));
+    }
+    else {
+        // Fresh clone
+        await mkdir(dirname(targetDir), { recursive: true });
+        console.log(chalk.dim(`[open] Cloning ${repoUrl} → ${targetDir}`));
+        await execFileAsync("git", [
+            "clone",
+            "--branch",
+            branch,
+            repoUrl,
+            targetDir,
+        ]);
+        console.log(chalk.green(`[open] Cloned and checked out ${branch}`));
+    }
+}
+//# sourceMappingURL=clone-and-checkout.js.map