@northflare/runner 0.0.30 → 0.0.32

package/dist/components/enhanced-repository-manager.js

@@ -1,1097 +0,0 @@
-/**
- * EnhancedRepositoryManager - Advanced Git repository management with worktree support
- *
- * This enhanced version builds upon the original RepositoryManager to add:
- * - Task-level Git isolation through worktrees
- * - Git operations (stage, commit, push, merge, rebase)
- * - State persistence and recovery
- * - Backward compatibility with workspace-based operations
- *
- * Directory structure:
- * /workspace/repos/<owner>__<repo>/
- *   control/                  # Primary clone (.git directory owner)
- *     .git/
- *   worktrees/
- *     workspace_<workspaceId>/ # Backward compatibility - workspace default branch
- *     task_<taskId>/          # New - isolated task worktrees
- *   state.json               # Persistent state mapping
- */
-import { RepositoryManager } from './repository-manager.js';
-import path from "path";
-import fs from "fs/promises";
-import crypto from "crypto";
-import { simpleGit } from "simple-git";
-import { createScopedConsole } from '../utils/console.js';
-import { createLogger } from '../utils/logger.js';
-const console = createScopedConsole("repo");
-const logger = createLogger("EnhancedRepositoryManager", "repo");
-export class EnhancedRepositoryManager extends RepositoryManager {
-    repoStates;
-    stateFilePath;
-    legacyStateFilePath;
-    repoLocks;
-    taskWorktreesBasePath;
-    constructor(runner) {
-        super(runner);
-        this.repoStates = new Map();
-        this.repoLocks = new Map();
-        const dataDir = runner.config_.dataDir;
-        const runnerId = runner.getRunnerId();
-        const stateFileName = runnerId
-            ? `repository-state-${runnerId}.json`
-            : "repository-state.json";
-        this.stateFilePath = path.join(dataDir, "git", stateFileName);
-        this.legacyStateFilePath = path.join(this.repoBasePath, "repository-state.json");
-        this.taskWorktreesBasePath = path.join(dataDir, "git", "worktrees");
-        // Load persisted state on initialization
-        this.restoreState().catch((err) => {
-            console.error("Failed to restore repository state:", err);
-        });
-    }
-    /**
-     * Get repository key from owner and repo name
-     */
-    getRepoKey(repoUrl) {
-        // Handle local repository URLs
-        if (repoUrl.startsWith("file://")) {
-            const localPath = repoUrl.replace("file://", "");
-            const repoName = path.basename(localPath) || "local";
-            const digest = crypto
-                .createHash("sha1")
-                .update(localPath)
-                .digest("hex")
-                .slice(0, 12);
-            return { key: `local__${repoName}__${digest}`, owner: "local", repo: repoName };
-        }
-        // Extract owner and repo from URL
-        const match = repoUrl.match(/github\.com[:/]([^/]+)\/([^/.]+)(\.git)?$/);
-        if (!match) {
-            throw new Error(`Invalid GitHub repository URL: ${repoUrl}`);
-        }
-        const owner = match[1] || "";
-        const repo = match[2] || "";
-        const key = `${owner}__${repo}`;
-        return { key, owner, repo };
-    }
-    parseRepoKey(repoKey) {
-        const parts = repoKey.split("__");
-        const owner = parts[0] || repoKey;
-        const repo = parts[1] || repoKey;
-        return { owner, repo };
-    }
-    findTaskStateEntry(taskId) {
-        for (const [repoKey, state] of this.repoStates) {
-            const repo = state.repositories[repoKey];
-            const taskState = repo?.worktrees?.[taskId];
-            if (repo && taskState) {
-                return { repoKey, repo, taskState };
-            }
-        }
-        return null;
-    }
-    async withRepoLock(repoKey, fn) {
-        const previous = this.repoLocks.get(repoKey) ?? Promise.resolve();
-        let release;
-        const current = new Promise((resolve) => {
-            release = resolve;
-        });
-        const chained = previous.then(() => current);
-        this.repoLocks.set(repoKey, chained);
-        await previous;
-        try {
-            return await fn();
-        }
-        finally {
-            release();
-            if (this.repoLocks.get(repoKey) === chained) {
-                this.repoLocks.delete(repoKey);
-            }
-        }
-    }
-    /**
-     * Ensure control repository exists
-     */
-    async ensureControlRepository(repoUrl, githubToken) {
-        const { key, owner, repo } = this.getRepoKey(repoUrl);
-        const controlPath = path.join(this.repoBasePath, "repos", key, "control");
-        // Check if control repository already exists
-        try {
-            // Support both bare repos (config/objects at root) and legacy non-bare repos (.git/)
-            const hasGitDir = await fs
-                .access(path.join(controlPath, ".git"))
-                .then(() => true)
-                .catch(() => false);
-            const hasBareLayout = await fs
-                .access(path.join(controlPath, "config"))
-                .then(() => fs.access(path.join(controlPath, "objects")).then(() => true))
-                .catch(() => false);
-            if (!hasGitDir && !hasBareLayout) {
-                throw new Error("missing");
-            }
-            console.log(`Control repository already exists for ${key}`);
-            // Update remote URL if token changed
-            if (githubToken) {
-                const git = simpleGit(controlPath);
-                const authUrl = this.getAuthenticatedUrl(repoUrl, githubToken);
-                await git.remote(["set-url", "origin", authUrl]);
-            }
-            // Fetch latest changes
-            const git = simpleGit(controlPath);
-            await git.fetch("origin");
-            return controlPath;
-        }
-        catch {
-            // Control repository doesn't exist, create it
-            console.log(`Creating control repository for ${key}...`);
-            await this.ensureDirectory(path.dirname(controlPath));
-            const authUrl = this.getAuthenticatedUrl(repoUrl, githubToken);
-            await this.executeGit(["clone", "--bare", authUrl, controlPath]);
-            console.log(`Successfully created control repository for ${key}`);
-            return controlPath;
-        }
-    }
-    /**
-     * Create a task-specific worktree for local workspaces
-     */
-    async createLocalTaskHandle(taskId, localPath) {
-        // For local workspaces, we don't create worktrees or branches
-        // Just return a handle pointing to the local path
-        const handle = {
-            taskId,
-            worktreePath: localPath,
-            branch: "local", // Placeholder branch name for local workspaces
-            baseBranch: "local",
-        };
-        // Create and persist state for tracking
-        const state = {
-            taskId,
-            branch: "local",
-            baseBranch: "local",
-            worktreePath: localPath,
-            status: "active",
-            createdAt: new Date(),
-            updatedAt: new Date(),
-        };
-        // Store state using a special key for local workspaces
-        await this.updateTaskState("__local__", state);
-        console.log(`Created local task handle for task ${taskId} at ${localPath}`);
-        return handle;
-    }
-    /**
-     * Create a task-specific worktree
-     */
-    async createTaskWorktree(taskId, workspaceId, repoUrl, baseBranch = "main", githubToken) {
-        const { key, owner, repo } = this.getRepoKey(repoUrl);
-        // Reuse an existing worktree/branch for this task when possible
-        const existing = this.findTaskStateEntry(taskId);
-        if (existing && existing.repoKey !== "__local__" && existing.taskState.branch !== "local") {
-            const expectedWorktreePath = path.join(this.taskWorktreesBasePath, existing.repoKey, `task_${taskId}`);
-            const worktreePath = existing.taskState.worktreePath || expectedWorktreePath;
-            const shouldPersistMetadata = existing.taskState.workspaceId !== workspaceId ||
-                existing.taskState.baseBranch !== baseBranch;
-            if (shouldPersistMetadata) {
-                existing.taskState.workspaceId = workspaceId;
-                existing.taskState.baseBranch = baseBranch;
-                existing.taskState.updatedAt = new Date();
-                await this.updateTaskStateByTaskId(taskId, existing.taskState);
-            }
-            try {
-                await fs.access(worktreePath);
-                return {
-                    taskId,
-                    worktreePath,
-                    branch: existing.taskState.branch,
-                    baseBranch: existing.taskState.baseBranch,
-                };
-            }
-            catch {
-                // Recreate missing worktree from the existing branch
-                const git = simpleGit(existing.repo.controlPath);
-                await this.ensureDirectory(path.dirname(worktreePath));
-                try {
-                    await git.raw(["worktree", "add", worktreePath, existing.taskState.branch]);
-                }
-                catch (error) {
-                    console.error(`Failed to recreate worktree for task ${taskId}:`, error);
-                    await this.cleanupDirectory(worktreePath);
-                    throw error;
-                }
-                const worktreeGit = simpleGit(worktreePath);
-                await worktreeGit.addConfig("user.name", "Northflare");
-                await worktreeGit.addConfig("user.email", "runner@northflare.ai");
-                existing.taskState.worktreePath = worktreePath;
-                existing.taskState.workspaceId = workspaceId;
-                existing.taskState.baseBranch = baseBranch;
-                existing.taskState.status = "active";
-                existing.taskState.updatedAt = new Date();
-                await this.updateTaskState(existing.repoKey, existing.taskState);
-                return {
-                    taskId,
-                    worktreePath,
-                    branch: existing.taskState.branch,
-                    baseBranch: existing.taskState.baseBranch,
-                };
-            }
-        }
-        const isLocalRepo = repoUrl.startsWith("file://");
-        // Ensure control repository exists
-        let controlPath;
-        if (isLocalRepo) {
-            controlPath = repoUrl.replace("file://", "");
-            // Verify local path exists and has a Git directory
-            const stats = await fs.stat(controlPath);
-            if (!stats.isDirectory()) {
-                throw new Error(`Local repository path is not a directory: ${controlPath}`);
-            }
-            await fs.access(path.join(controlPath, ".git"));
-        }
-        else {
-            controlPath = await this.ensureControlRepository(repoUrl, githubToken);
-        }
-        const worktreesPath = path.join(this.taskWorktreesBasePath, key);
-        const taskWorktreePath = path.join(worktreesPath, `task_${taskId}`);
-        // Create unique branch name for the task
-        const branchName = `task/${taskId}`;
-        try {
-            console.log(`Creating worktree for task ${taskId} on branch ${branchName}...`);
-            // Create worktree directory
-            await this.ensureDirectory(worktreesPath);
-            // Add worktree with new branch based on baseBranch
-            const git = simpleGit(controlPath);
-            const baseRef = isLocalRepo ? baseBranch : `origin/${baseBranch}`;
-            let baseRefIsValid = await git
-                .raw(["rev-parse", "--verify", `${baseRef}^{commit}`])
-                .then(() => true)
-                .catch(() => false);
-            if (!baseRefIsValid) {
-                const hasAnyCommit = await git
-                    .raw(["rev-parse", "--verify", "HEAD^{commit}"])
-                    .then(() => true)
-                    .catch(() => false);
-                if (!hasAnyCommit) {
-                    await this.ensureInitialCommitOnBranch(controlPath, baseBranch);
-                    baseRefIsValid = await git
-                        .raw(["rev-parse", "--verify", `${baseRef}^{commit}`])
-                        .then(() => true)
-                        .catch(() => false);
-                }
-                if (!baseRefIsValid) {
-                    throw new Error(`Cannot create a task worktree for ${taskId}: base branch '${baseBranch}' is not a valid Git reference in ${controlPath}. Set Workspace → Settings → Git branch to an existing branch name and retry.`);
-                }
-            }
-            const branchExists = await git
-                .raw(["show-ref", "--verify", `refs/heads/${branchName}`])
-                .then(() => true)
-                .catch(() => false);
-            if (branchExists) {
-                await git.raw(["worktree", "add", taskWorktreePath, branchName]);
-            }
-            else {
-                await git.raw([
-                    "worktree",
-                    "add",
-                    "-b",
-                    branchName,
-                    taskWorktreePath,
-                    baseRef,
-                ]);
-            }
-            // Configure the worktree
-            const worktreeGit = simpleGit(taskWorktreePath);
-            await worktreeGit.addConfig("user.name", "Northflare");
-            await worktreeGit.addConfig("user.email", "runner@northflare.ai");
-            // Create and persist state
-            const state = {
-                taskId,
-                workspaceId,
-                branch: branchName,
-                baseBranch,
-                worktreePath: taskWorktreePath,
-                status: "active",
-                createdAt: new Date(),
-                updatedAt: new Date(),
-            };
-            await this.updateTaskState(key, state, { owner, repo, controlPath });
-            console.log(`Successfully created worktree for task ${taskId}`);
-            return {
-                taskId,
-                worktreePath: taskWorktreePath,
-                branch: branchName,
-                baseBranch,
-            };
-        }
-        catch (error) {
-            console.error(`Failed to create worktree for task ${taskId}:`, error);
-            // Cleanup on failure
-            await this.cleanupDirectory(taskWorktreePath);
-            throw error;
-        }
-    }
-    async ensureInitialCommitOnBranch(repoPath, branchName) {
-        const git = simpleGit(repoPath);
-        await git.addConfig("user.name", "Northflare");
-        await git.addConfig("user.email", "runner@northflare.ai");
-        const hasAnyCommit = await git
-            .raw(["rev-parse", "--verify", "HEAD^{commit}"])
-            .then(() => true)
-            .catch(() => false);
-        if (hasAnyCommit)
-            return;
-        console.log(`Repository at ${repoPath} has no commits; creating an empty initial commit on '${branchName}'...`);
-        const isBareRepo = await git
-            .raw(["rev-parse", "--is-bare-repository"])
-            .then((output) => output.trim() === "true")
-            .catch(() => false);
-        if (isBareRepo) {
-            const emptyTreeHash = "4b825dc642cb6eb9a060e54bf8d69288fbee4904";
-            const commitHash = (await git.raw([
-                "commit-tree",
-                emptyTreeHash,
-                "-m",
-                "Initial commit",
-            ])).trim();
-            await git.raw(["update-ref", `refs/heads/${branchName}`, commitHash]);
-            await git.raw(["symbolic-ref", "HEAD", `refs/heads/${branchName}`]);
-            const remotes = await git.getRemotes(true);
-            const hasOrigin = remotes.some((remote) => remote.name === "origin");
-            void hasOrigin;
-        }
-        else {
-            await git.raw(["checkout", "--orphan", branchName]);
-            await git.raw(["commit", "--allow-empty", "-m", "Initial commit"]);
-        }
-    }
-    /**
-     * Remove a task worktree
-     */
-    async removeTaskWorktree(taskId, options = {}) {
-        const entry = this.findTaskStateEntry(taskId);
-        if (!entry) {
-            console.log(`No worktree found for task ${taskId}`);
-            return;
-        }
-        const { repoKey, repo, taskState } = entry;
-        // Handle local workspaces differently
-        if (repoKey === "__local__") {
-            // Just remove from state, don't touch the filesystem
-            const repoState = this.repoStates.get(repoKey);
-            const repo = repoState?.repositories?.[repoKey];
-            if (repo?.worktrees?.[taskId]) {
-                delete repo.worktrees[taskId];
-            }
-            await this.persistState();
-            console.log(`Removed local task handle for task ${taskId}`);
-            return;
-        }
-        const controlPath = repo.controlPath;
-        try {
-            console.log(`Removing worktree for task ${taskId}...`);
-            const git = simpleGit(controlPath);
-            // Remove the worktree (when present)
-            if (taskState.worktreePath) {
-                const worktreePath = taskState.worktreePath;
-                try {
-                    await fs.access(worktreePath);
-                    await git.raw(["worktree", "remove", worktreePath, "--force"]);
-                }
-                catch {
-                    // Worktree path already gone; continue so we can still delete the branch if needed
-                }
-                finally {
-                    await this.cleanupDirectory(worktreePath);
-                }
-            }
-            // Delete the branch if not preserving
-            if (!options.preserveBranch) {
-                try {
-                    await git.raw(["branch", "-D", taskState.branch]);
-                }
-                catch (error) {
-                    console.warn(`Failed to delete branch ${taskState.branch}:`, error);
-                }
-            }
-            // Update state
-            const repoState = this.repoStates.get(repoKey);
-            if (repoState?.repositories[repoKey]?.worktrees) {
-                if (options.preserveBranch) {
-                    repoState.repositories[repoKey].worktrees[taskId] = {
-                        ...taskState,
-                        worktreePath: "",
-                        updatedAt: new Date(),
-                    };
-                }
-                else {
-                    delete repoState.repositories[repoKey].worktrees[taskId];
-                }
-            }
-            await this.persistState();
-            console.log(`Successfully removed worktree for task ${taskId}`);
-        }
-        catch (error) {
-            console.error(`Failed to remove worktree for task ${taskId}:`, error);
-            if (options.force) {
-                // Force cleanup
-                await this.cleanupDirectory(taskState.worktreePath);
-            }
-            else {
-                throw error;
-            }
-        }
-    }
-    /**
-     * Stage all changes in a task worktree
-     */
-    async stageAll(taskId) {
-        const taskState = await this.getTaskState(taskId);
-        if (!taskState) {
-            throw new Error(`No worktree found for task ${taskId}`);
-        }
-        // Skip Git operations for local workspaces
-        if (taskState.branch === "local") {
-            console.log(`Skipping stage operation for local workspace task ${taskId}`);
-            return;
-        }
-        const git = simpleGit(taskState.worktreePath);
-        await git.add(".");
-        console.log(`Staged all changes for task ${taskId}`);
-    }
-    /**
-     * Commit changes in a task worktree
-     */
-    async commit(taskId, message, author) {
-        const taskState = await this.getTaskState(taskId);
-        if (!taskState) {
-            throw new Error(`No worktree found for task ${taskId}`);
-        }
-        // Skip Git operations for local workspaces
-        if (taskState.branch === "local") {
-            console.log(`Skipping commit operation for local workspace task ${taskId}`);
-            return "local-commit"; // Return a placeholder commit hash
-        }
-        const git = simpleGit(taskState.worktreePath);
-        // Set author if provided
-        if (author) {
-            await git.addConfig("user.name", author.name);
-            await git.addConfig("user.email", author.email);
-        }
-        // Commit changes
-        const result = await git.commit(message);
-        const commitHash = result.commit;
-        // Update task state
-        taskState.lastCommit = commitHash;
-        taskState.commitCount = (taskState.commitCount ?? 0) + 1;
-        taskState.updatedAt = new Date();
-        await this.updateTaskStateByTaskId(taskId, taskState);
-        console.log(`Created commit ${commitHash} for task ${taskId}`);
-        logger.info(`Committed task ${taskId} (${taskState.branch}) -> ${commitHash}`, {
-            taskId,
-            branch: taskState.branch,
-            baseBranch: taskState.baseBranch,
-            commit: commitHash,
-            worktreePath: taskState.worktreePath,
-        });
-        return commitHash;
-    }
-    /**
-     * Create a new branch for a task
-     */
-    async createBranch(taskId, branchName) {
-        const taskState = await this.getTaskState(taskId);
-        if (!taskState) {
-            throw new Error(`No worktree found for task ${taskId}`);
-        }
-        // Skip Git operations for local workspaces
-        if (taskState.branch === "local") {
-            console.log(`Skipping branch creation for local workspace task ${taskId}`);
-            return;
-        }
-        const git = simpleGit(taskState.worktreePath);
-        await git.checkoutBranch(branchName, taskState.branch);
-        // Update task state
-        taskState.branch = branchName;
-        taskState.updatedAt = new Date();
-        await this.updateTaskStateByTaskId(taskId, taskState);
-        console.log(`Created branch ${branchName} for task ${taskId}`);
-    }
-    /**
-     * Rebase a task branch onto target branch
-     */
-    async rebaseTask(taskId, targetBranch) {
-        const taskState = await this.getTaskState(taskId);
-        if (!taskState) {
-            throw new Error(`No worktree found for task ${taskId}`);
-        }
-        // Skip Git operations for local workspaces
-        if (taskState.branch === "local") {
-            console.log(`Skipping rebase operation for local workspace task ${taskId}`);
-            return { success: true }; // Return success for local workspaces
-        }
-        const git = simpleGit(taskState.worktreePath);
-        try {
-            const remotes = await git.getRemotes(true);
-            const hasOrigin = remotes.some((r) => r.name === "origin");
-            logger.info(`Rebasing task ${taskId} (${taskState.branch}) onto ${targetBranch}`, {
-                taskId,
-                branch: taskState.branch,
-                targetBranch,
-                hasOrigin,
-                worktreePath: taskState.worktreePath,
-            });
-            if (hasOrigin) {
-                // Fetch latest changes
-                await git.fetch("origin", targetBranch);
-                // Perform rebase
-                await git.rebase([`origin/${targetBranch}`]);
-            }
-            else {
-                await git.rebase([targetBranch]);
-            }
-            // Update base branch in state
-            taskState.baseBranch = targetBranch;
-            taskState.updatedAt = new Date();
-            await this.updateTaskStateByTaskId(taskId, taskState);
-            console.log(`Successfully rebased task ${taskId} onto ${targetBranch}`);
-            logger.info(`Rebased task ${taskId} (${taskState.branch}) onto ${targetBranch}`, {
-                taskId,
-                branch: taskState.branch,
-                targetBranch,
-            });
-            return { success: true };
-        }
-        catch (error) {
-            console.error(`Rebase failed for task ${taskId}:`, error);
-            logger.error(`Rebase failed for task ${taskId} (${taskState.branch})`, {
-                taskId,
-                branch: taskState.branch,
-                targetBranch,
-                error: error instanceof Error ? error.message : String(error),
-            });
-            // Check for conflicts
-            const status = await git.status();
-            if (status.conflicted.length > 0) {
-                taskState.status = "conflicted";
-                await this.updateTaskStateByTaskId(taskId, taskState);
-                return {
-                    success: false,
-                    conflicts: status.conflicted,
-                    error: "Rebase resulted in conflicts",
-                };
-            }
-            // Abort rebase on error
-            try {
-                await git.rebase(["--abort"]);
-            }
-            catch {
-                // Ignore abort errors
-            }
-            return {
-                success: false,
-                error: error instanceof Error ? error.message : String(error),
-            };
-        }
-    }
-    /**
-     * Merge a task branch into target branch
-     */
-    async mergeTask(taskId, targetBranch, mode = "no-ff") {
-        const entry = this.findTaskStateEntry(taskId);
-        if (!entry) {
-            throw new Error(`No worktree found for task ${taskId}`);
-        }
-        const { repoKey, taskState } = entry;
-        // Skip Git operations for local workspaces
-        if (taskState.branch === "local") {
-            console.log(`Skipping merge operation for local workspace task ${taskId}`);
-            return { success: true, mergedCommit: "local-merge" }; // Return success for local workspaces
-        }
-        return await this.withRepoLock(repoKey, async () => {
-            return this.mergeTaskUnlocked(entry, targetBranch, mode);
-        });
-    }
-    async mergeTaskUnlocked(entry, targetBranch, mode) {
-        const { repoKey, repo, taskState } = entry;
-        const isLocalRepo = repoKey.startsWith("local__");
-        const mergePath = await (async () => {
-            if (isLocalRepo)
-                return repo.controlPath;
-            if (!taskState.workspaceId) {
-                throw new Error(`Cannot merge task ${taskState.taskId}: missing workspaceId in task Git state`);
-            }
-            const worktreesPath = path.join(this.repoBasePath, "repos", repoKey, "worktrees");
-            const workspaceWorktreePath = path.join(worktreesPath, `workspace_${taskState.workspaceId}`);
-            const exists = await fs
-                .access(workspaceWorktreePath)
-                .then(() => true)
-                .catch(() => false);
-            if (exists)
-                return workspaceWorktreePath;
-            await this.ensureDirectory(worktreesPath);
-            const controlGit = simpleGit(repo.controlPath);
-            await controlGit.fetch("origin", targetBranch);
-            await controlGit.raw([
-                "worktree",
-                "add",
-                workspaceWorktreePath,
-                `origin/${targetBranch}`,
-            ]);
-            console.log(`Created merge worktree for workspace ${taskState.workspaceId} at ${workspaceWorktreePath}`);
-            return workspaceWorktreePath;
-        })();
-        const git = simpleGit(mergePath);
-        try {
-            const remotes = await git.getRemotes(true);
-            const hasOrigin = remotes.some((r) => r.name === "origin");
-            logger.info(`Merging task ${taskState.taskId} (${taskState.branch}) into ${targetBranch}`, {
-                taskId: taskState.taskId,
-                taskBranch: taskState.branch,
-                targetBranch,
-                mergePath,
-                hasOrigin,
-                isLocalRepo,
-                mode,
-            });
-            if (hasOrigin) {
-                // Fetch latest changes and ensure a local targetBranch exists + is up-to-date
-                await git.fetch("origin", targetBranch);
-                const localBranches = await git.branchLocal();
-                const hasLocalTarget = localBranches.all.includes(targetBranch);
-                if (!hasLocalTarget) {
-                    await git.raw(["checkout", "-B", targetBranch, `origin/${targetBranch}`]);
-                }
-                else {
-                    await git.checkout(targetBranch);
-                    try {
-                        await git.merge(["--ff-only", `origin/${targetBranch}`]);
-                    }
-                    catch (error) {
-                        throw new Error(`Base branch ${targetBranch} has diverged from origin/${targetBranch}; cannot fast-forward`);
-                    }
-                }
-            }
-            else {
-                await git.checkout(targetBranch);
-            }
-            // Perform merge based on mode
-            let mergeArgs = [];
-            switch (mode) {
-                case "ff-only":
-                    mergeArgs = ["--ff-only"];
-                    break;
-                case "no-ff":
-                    mergeArgs = ["--no-ff"];
-                    break;
-                case "squash":
-                    mergeArgs = ["--squash"];
-                    break;
-            }
-            const result = await git.merge([...mergeArgs, taskState.branch]);
-            // For squash merge, we need to commit
-            if (mode === "squash") {
-                const commitResult = await git.commit(`Merge task ${taskState.taskId} (${taskState.branch})`);
-                result.result = commitResult.commit;
-            }
-            // Update task state
-            taskState.status = "merged";
-            taskState.updatedAt = new Date();
-            await this.updateTaskStateByTaskId(taskState.taskId, taskState);
-            console.log(`Successfully merged task ${taskState.taskId} into ${targetBranch}`);
-            logger.info(`Merged task ${taskState.taskId} (${taskState.branch}) into ${targetBranch}`, {
-                taskId: taskState.taskId,
-                taskBranch: taskState.branch,
-                targetBranch,
-                mergedCommit: result.result,
-            });
-            return {
-                success: true,
-                mergedCommit: result.result,
-            };
-        }
-        catch (error) {
-            console.error(`Merge failed for task ${taskState.taskId}:`, error);
-            logger.error(`Merge failed for task ${taskState.taskId} (${taskState.branch})`, {
-                taskId: taskState.taskId,
-                taskBranch: taskState.branch,
-                targetBranch,
-                mergePath,
-                error: error instanceof Error ? error.message : String(error),
-            });
-            // Check for conflicts
-            try {
-                const status = await git.status();
-                if (status.conflicted.length > 0) {
-                    taskState.status = "conflicted";
-                    await this.updateTaskStateByTaskId(taskState.taskId, taskState);
-                    return {
-                        success: false,
-                        conflicts: status.conflicted,
-                        error: "Merge resulted in conflicts",
-                    };
-                }
-            }
-            catch {
-                // Ignore status errors (e.g. bare repositories)
-            }
-            return {
-                success: false,
-                error: error instanceof Error ? error.message : String(error),
-            };
-        }
-    }
-    async getTaskRepoInfo(taskId) {
-        const entry = this.findTaskStateEntry(taskId);
-        if (!entry)
-            return null;
-        return {
-            repoKey: entry.repoKey,
-            controlPath: entry.repo.controlPath,
-            worktreePath: entry.taskState.worktreePath,
-            branch: entry.taskState.branch,
-            baseBranch: entry.taskState.baseBranch,
-        };
-    }
-    /**
-     * Fast-forward (or hard reset) the shared workspace worktree to a branch tip after a task merge.
-     * This keeps the "workspace" checkout in sync with concurrent task integrations.
-     *
-     * We only update existing workspace worktrees and only when they're clean to avoid
-     * clobbering any active non-concurrent task that might be using the workspace checkout.
-     */
-    async syncWorkspaceWorktree(workspaceId, repoUrl, branch) {
-        if (!workspaceId || !repoUrl)
-            return;
-        // Local repos merge directly into the primary working tree (controlPath), nothing to sync.
-        if (repoUrl.startsWith("file://"))
-            return;
-        const { key } = this.getRepoKey(repoUrl);
-        const workspaceWorktreePath = path.join(this.repoBasePath, "repos", key, "worktrees", `workspace_${workspaceId}`);
-        const exists = await fs
-            .access(workspaceWorktreePath)
-            .then(() => true)
-            .catch(() => false);
-        await this.withRepoLock(key, async () => {
-            if (!exists) {
-                const controlPath = path.join(this.repoBasePath, "repos", key, "control");
-                const controlExists = await fs
-                    .access(controlPath)
-                    .then(() => true)
-                    .catch(() => false);
-                if (!controlExists) {
-                    console.warn(`Skipping workspace worktree sync for ${workspaceId}: control repo missing`, { controlPath, repoUrl });
-                    return;
-                }
-                await this.ensureDirectory(path.dirname(workspaceWorktreePath));
-                const controlGit = simpleGit(controlPath);
-                const remotes = await controlGit.getRemotes(true);
-                const hasOrigin = remotes.some((remote) => remote.name === "origin");
-                const checkoutRef = hasOrigin ? `origin/${branch}` : branch;
-                await controlGit.raw(["worktree", "add", workspaceWorktreePath, checkoutRef]);
-                console.log(`Created workspace worktree for ${workspaceId} at ${workspaceWorktreePath}`);
-            }
-            const git = simpleGit(workspaceWorktreePath);
-            const status = await git.status();
-            if (status.conflicted.length > 0 || !status.isClean()) {
-                console.warn(`Skipping workspace worktree sync for ${workspaceId}: worktree is not clean`, {
-                    path: workspaceWorktreePath,
-                    branch,
-                    conflicted: status.conflicted,
-                    fileCount: status.files.length,
-                });
-                return;
-            }
-            const remotes = await git.getRemotes(true);
-            const hasOrigin = remotes.some((remote) => remote.name === "origin");
-            if (hasOrigin) {
-                await git.fetch("origin", branch);
-                await git.reset(["--hard", `origin/${branch}`]);
-            }
-            else {
-                await git.reset(["--hard", branch]);
-            }
-            await git.clean("f", ["-d"]);
-            console.log(`Synced workspace worktree for ${workspaceId} to ${branch} at ${workspaceWorktreePath}`);
-        });
-    }
-    async isTaskBranchMerged(taskId, targetBranch) {
-        const entry = this.findTaskStateEntry(taskId);
-        if (!entry)
-            return false;
-        const { repo, taskState } = entry;
-        const git = simpleGit(repo.controlPath);
-        try {
-            // Ensure targetBranch exists locally (avoid erroring for repos that only have origin/<branch>)
-            const showRef = await git.raw([
-                "show-ref",
-                "--verify",
-                `refs/heads/${targetBranch}`,
-            ]);
-            if (!showRef?.trim())
-                return false;
-        }
-        catch {
-            return false;
-        }
-        try {
-            await git.raw([
-                "merge-base",
-                "--is-ancestor",
-                taskState.branch,
-                targetBranch,
-            ]);
-            return true;
-        }
-        catch {
-            return false;
-        }
-    }
-    async pushBranch(taskId, branch) {
-        const entry = this.findTaskStateEntry(taskId);
-        if (!entry)
-            return;
-        const git = simpleGit(entry.repo.controlPath);
-        const remotes = await git.getRemotes(true);
-        const hasOrigin = remotes.some((r) => r.name === "origin");
-        if (!hasOrigin)
-            return;
-        await git.push("origin", branch);
-    }
-    async integrateTask(taskId, targetBranch, mode = "no-ff") {
-        const entry = this.findTaskStateEntry(taskId);
-        if (!entry) {
-            return {
-                success: false,
-                phase: "merge",
-                error: `No worktree found for task ${taskId}`,
-                conflictWorkdir: "",
-            };
-        }
-        const { repoKey, repo, taskState } = entry;
-        const isLocalRepo = repoKey.startsWith("local__");
-        const mergeWorkdir = isLocalRepo
-            ? repo.controlPath
-            : taskState.workspaceId
-                ? path.join(this.repoBasePath, "repos", repoKey, "worktrees", `workspace_${taskState.workspaceId}`)
-                : taskState.worktreePath;
-        logger.info(`Integrating task ${taskId} (${taskState.branch}) into ${targetBranch}`, {
-            taskId,
-            taskBranch: taskState.branch,
-            targetBranch,
-            mode,
-            isLocalRepo,
-            controlPath: repo.controlPath,
-            worktreePath: taskState.worktreePath,
-        });
-        return await this.withRepoLock(repoKey, async () => {
-            const rebaseResult = await this.rebaseTask(taskId, targetBranch);
-            if (!rebaseResult.success) {
-                logger.warn(`Task ${taskId} rebase failed`, {
-                    taskId,
-                    phase: "rebase",
-                    targetBranch,
-                    conflicts: rebaseResult.conflicts ?? [],
-                    error: rebaseResult.error,
-                });
-                return {
-                    success: false,
-                    phase: "rebase",
-                    conflicts: rebaseResult.conflicts ?? [],
-                    error: rebaseResult.error,
-                    conflictWorkdir: taskState.worktreePath,
-                };
-            }
-            const mergeResult = await this.mergeTaskUnlocked(entry, targetBranch, mode);
-            if (!mergeResult.success) {
-                logger.warn(`Task ${taskId} merge failed`, {
-                    taskId,
-                    phase: "merge",
-                    targetBranch,
-                    conflicts: mergeResult.conflicts ?? [],
-                    error: mergeResult.error,
-                });
-                return {
-                    success: false,
-                    phase: "merge",
-                    conflicts: mergeResult.conflicts ?? [],
-                    error: mergeResult.error,
-                    conflictWorkdir: mergeWorkdir,
-                };
-            }
-            logger.info(`Integrated task ${taskId} into ${targetBranch}`, {
-                taskId,
-                targetBranch,
-                mergedCommit: mergeResult.mergedCommit,
-            });
-            return {
-                success: true,
-                mergedCommit: mergeResult.mergedCommit,
-            };
-        });
-    }
-    /**
-     * Get task Git state
-     */
-    async getTaskState(taskId) {
-        return this.findTaskStateEntry(taskId)?.taskState ?? null;
-    }
-    /**
-     * Update task state
-     */
-    async updateTaskState(repoKey, state, repoInfo) {
-        if (!this.repoStates.has(repoKey)) {
-            this.repoStates.set(repoKey, {
-                repositories: {},
-            });
-        }
-        const repoState = this.repoStates.get(repoKey);
-        if (!repoState.repositories[repoKey]) {
-            // Handle special case for local workspaces
-            if (repoKey === "__local__") {
-                repoState.repositories[repoKey] = {
-                    owner: "local",
-                    repo: "local",
-                    controlPath: "local",
-                    worktrees: {},
-                };
-            }
-            else if (repoInfo) {
-                repoState.repositories[repoKey] = {
-                    owner: repoInfo.owner,
-                    repo: repoInfo.repo,
-                    controlPath: repoInfo.controlPath,
-                    worktrees: {},
-                };
-            }
-            else {
-                const { owner, repo } = this.parseRepoKey(repoKey);
-                repoState.repositories[repoKey] = {
-                    owner,
-                    repo,
-                    controlPath: path.join(this.repoBasePath, "repos", repoKey, "control"),
-                    worktrees: {},
-                };
-            }
-        }
-        else if (repoInfo?.controlPath) {
-            // Ensure we persist the latest controlPath (important for local repos)
-            repoState.repositories[repoKey].controlPath = repoInfo.controlPath;
-        }
-        repoState.repositories[repoKey].worktrees[state.taskId] = state;
-        await this.persistState();
-    }
-    /**
-     * Update task state by task ID
-     */
-    async updateTaskStateByTaskId(taskId, state) {
-        for (const [repoKey, repoState] of this.repoStates) {
-            for (const repo of Object.values(repoState.repositories)) {
-                if (repo.worktrees[taskId]) {
-                    repo.worktrees[taskId] = state;
-                    await this.persistState();
-                    return;
-                }
-            }
-        }
-    }
-    /**
-     * Persist state to disk
-     */
-    async persistState() {
-        try {
-            const stateData = {};
-            for (const [key, value] of this.repoStates) {
-                stateData[key] = value;
-            }
-            await this.ensureDirectory(path.dirname(this.stateFilePath));
-            await fs.writeFile(this.stateFilePath, JSON.stringify(stateData, null, 2));
-            console.log("Persisted repository state");
-        }
-        catch (error) {
-            console.error("Failed to persist repository state:", error);
-        }
-    }
-    /**
-     * Restore state from disk
-     */
-    async restoreState() {
-        await this.migrateLegacyStateFileIfNeeded();
-        try {
-            const data = await fs.readFile(this.stateFilePath, "utf-8");
-            const stateData = JSON.parse(data);
-            this.repoStates.clear();
-            for (const [key, value] of Object.entries(stateData)) {
-                // Convert date strings back to Date objects
-                for (const repo of Object.values(value.repositories)) {
-                    for (const worktree of Object.values(repo.worktrees)) {
-                        worktree.createdAt = new Date(worktree.createdAt);
-                        worktree.updatedAt = new Date(worktree.updatedAt);
-                    }
-                }
-                this.repoStates.set(key, value);
-            }
-            console.log("Restored repository state");
-        }
-        catch (error) {
-            if (error.code !== "ENOENT") {
-                console.error("Failed to restore repository state:", error);
-            }
-            // If file doesn't exist, that's okay - we'll start fresh
-        }
-    }
-    async migrateLegacyStateFileIfNeeded() {
-        const hasNewStateFile = await fs
-            .access(this.stateFilePath)
-            .then(() => true)
-            .catch(() => false);
-        if (hasNewStateFile)
-            return;
-        const hasLegacyStateFile = await fs
-            .access(this.legacyStateFilePath)
-            .then(() => true)
-            .catch(() => false);
-        if (!hasLegacyStateFile)
-            return;
-        await this.ensureDirectory(path.dirname(this.stateFilePath));
-        await fs.rename(this.legacyStateFilePath, this.stateFilePath);
-        console.log(`Moved legacy repository state file to runner data directory: ${this.stateFilePath}`);
-    }
-    /**
-     * Override parent's checkoutRepository to use worktrees for backward compatibility
-     */
-    async checkoutRepository(workspaceId, repoUrl, branch, githubToken) {
-        // If it's a local repository URL, delegate to parent's checkoutLocalRepository
-        if (repoUrl.startsWith("file://")) {
-            const localPath = repoUrl.replace("file://", "");
-            return super.checkoutLocalRepository(workspaceId, localPath);
-        }
-        const { key } = this.getRepoKey(repoUrl);
-        // Ensure control repository exists
-        await this.ensureControlRepository(repoUrl, githubToken);
-        // Create or update workspace worktree
-        const worktreesPath = path.join(this.repoBasePath, "repos", key, "worktrees");
-        const workspaceWorktreePath = path.join(worktreesPath, `workspace_${workspaceId}`);
-        try {
-            // Check if workspace worktree already exists
-            await fs.access(workspaceWorktreePath);
-            // Update existing worktree
-            const git = simpleGit(workspaceWorktreePath);
-            await git.fetch("origin");
-            await git.reset(["--hard", `origin/${branch}`]);
-            await git.clean("f", ["-d"]);
-            console.log(`Updated workspace worktree for ${workspaceId}`);
-        }
-        catch {
-            // Create new workspace worktree
-            const controlPath = path.join(this.repoBasePath, "repos", key, "control");
-            const git = simpleGit(controlPath);
-            await this.ensureDirectory(worktreesPath);
-            await git.raw([
-                "worktree",
-                "add",
-                workspaceWorktreePath,
-                `origin/${branch}`,
-            ]);
-            console.log(`Created workspace worktree for ${workspaceId}`);
-        }
-        return workspaceWorktreePath;
-    }
-}
-//# sourceMappingURL=enhanced-repository-manager.js.map