@northflare/runner 0.0.12 → 0.0.13

package/src/components/enhanced-repository-manager.ts

@@ -1,823 +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";
-import { IRunnerApp } from "../types/runner-interface";
-import path from "path";
-import fs from "fs/promises";
-import simpleGit from "simple-git";
-import { console } from "../utils/console";
-
-// Types for enhanced functionality
-export interface TaskHandle {
-  taskId: string;
-  worktreePath: string;
-  branch: string;
-  baseBranch: string;
-}
-
-export interface RemoveOptions {
-  preserveBranch?: boolean;
-  force?: boolean;
-}
-
-export interface GitAuthor {
-  name: string;
-  email: string;
-}
-
-export interface RebaseResult {
-  success: boolean;
-  conflicts?: string[];
-  error?: string;
-}
-
-export interface MergeResult {
-  success: boolean;
-  conflicts?: string[];
-  mergedCommit?: string;
-  error?: string;
-}
-
-export type MergeMode = "ff-only" | "no-ff" | "squash";
-
-export interface TaskGitState {
-  taskId: string;
-  branch: string;
-  baseBranch: string;
-  lastCommit?: string;
-  worktreePath: string;
-  status: "active" | "conflicted" | "merged" | "abandoned";
-  createdAt: Date;
-  updatedAt: Date;
-}
-
-export interface RepositoryState {
-  repositories: Record<
-    string,
-    {
-      owner: string;
-      repo: string;
-      controlPath: string;
-      worktrees: Record<string, TaskGitState>;
-    }
-  >;
-}
-
-export class EnhancedRepositoryManager extends RepositoryManager {
-  private repoStates: Map<string, RepositoryState>;
-  private stateFilePath: string;
-
-  constructor(runner: IRunnerApp) {
-    super(runner);
-    this.repoStates = new Map();
-    // this.repoBasePath is set by parent constructor, so we can use it now
-    this.stateFilePath = path.join(this.repoBasePath, "repository-state.json");
-
-    // 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
-   */
-  private getRepoKey(repoUrl: string): {
-    key: string;
-    owner: string;
-    repo: string;
-  } {
-    // Handle local repository URLs
-    if (repoUrl.startsWith("file://")) {
-      const localPath = repoUrl.replace("file://", "");
-      const pathParts = localPath.split("/");
-      const repoName = pathParts[pathParts.length - 1] || "local";
-      return { key: `local__${repoName}`, 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 };
-  }
-
-  /**
-   * Ensure control repository exists
-   */
-  private async ensureControlRepository(
-    repoUrl: string,
-    githubToken?: string
-  ): Promise<string> {
-    const { key, owner, repo } = this.getRepoKey(repoUrl);
-    const controlPath = path.join(this.repoBasePath, "repos", key, "control");
-
-    // Check if control repository already exists
-    try {
-      await fs.access(path.join(controlPath, ".git"));
-      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]);
-
-      // Convert to regular repository for worktree support
-      const git = simpleGit(controlPath);
-      await git.raw(["config", "--bool", "core.bare", "false"]);
-
-      console.log(`Successfully created control repository for ${key}`);
-      return controlPath;
-    }
-  }
-
-  /**
-   * Create a task-specific worktree for local workspaces
-   */
-  async createLocalTaskHandle(
-    taskId: string,
-    localPath: string
-  ): Promise<TaskHandle> {
-    // For local workspaces, we don't create worktrees or branches
-    // Just return a handle pointing to the local path
-    const handle: TaskHandle = {
-      taskId,
-      worktreePath: localPath,
-      branch: "local", // Placeholder branch name for local workspaces
-      baseBranch: "local",
-    };
-
-    // Create and persist state for tracking
-    const state: TaskGitState = {
-      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: string,
-    workspaceId: string,
-    repoUrl: string,
-    baseBranch: string = "main",
-    githubToken?: string
-  ): Promise<TaskHandle> {
-    // For local repositories, just return the path without creating worktrees
-    if (repoUrl.startsWith("file://")) {
-      const localPath = repoUrl.replace("file://", "");
-      console.log(`Using local repository for task ${taskId}: ${localPath}`);
-
-      // Verify the path exists
-      try {
-        const stats = await fs.stat(localPath);
-        if (!stats.isDirectory()) {
-          throw new Error(`Path is not a directory: ${localPath}`);
-        }
-      } catch (error) {
-        console.error(`Local repository path not found: ${localPath}`);
-        throw new Error(`Local repository path not found: ${localPath}`);
-      }
-
-      return {
-        taskId,
-        worktreePath: localPath,
-        branch: "local",
-        baseBranch: "local",
-      };
-    }
-
-    const { key } = this.getRepoKey(repoUrl);
-
-    // Ensure control repository exists
-    const controlPath = await this.ensureControlRepository(
-      repoUrl,
-      githubToken
-    );
-    const worktreesPath = path.join(
-      this.repoBasePath,
-      "repos",
-      key,
-      "worktrees"
-    );
-    const taskWorktreePath = path.join(worktreesPath, `task_${taskId}`);
-
-    // Create unique branch name for the task
-    const timestamp = Date.now();
-    const shortTaskId = taskId.substring(0, 8);
-    const branchName = `task/${shortTaskId}-${timestamp}`;
-
-    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);
-      await git.raw([
-        "worktree",
-        "add",
-        "-b",
-        branchName,
-        taskWorktreePath,
-        `origin/${baseBranch}`,
-      ]);
-
-      // 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: TaskGitState = {
-        taskId,
-        branch: branchName,
-        baseBranch,
-        worktreePath: taskWorktreePath,
-        status: "active",
-        createdAt: new Date(),
-        updatedAt: new Date(),
-      };
-
-      await this.updateTaskState(key, state);
-
-      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;
-    }
-  }
-
-  /**
-   * Remove a task worktree
-   */
-  async removeTaskWorktree(
-    taskId: string,
-    options: RemoveOptions = {}
-  ): Promise<void> {
-    // Find the task state across all repositories
-    let repoKey: string | null = null;
-    let taskState: TaskGitState | null = null;
-
-    for (const [key, state] of this.repoStates) {
-      const repo = state.repositories[key];
-      if (repo?.worktrees[taskId]) {
-        repoKey = key;
-        taskState = repo.worktrees[taskId];
-        break;
-      }
-    }
-
-    if (!repoKey || !taskState) {
-      console.log(`No worktree found for task ${taskId}`);
-      return;
-    }
-
-    // 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 { key } = this.getRepoKey(repoKey);
-    const controlPath = path.join(this.repoBasePath, "repos", key, "control");
-
-    try {
-      console.log(`Removing worktree for task ${taskId}...`);
-
-      // Remove the worktree
-      const git = simpleGit(controlPath);
-      await git.raw(["worktree", "remove", taskState.worktreePath, "--force"]);
-
-      // 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);
-        }
-      }
-
-      // Remove from state
-      const repoState = this.repoStates.get(repoKey);
-      if (repoState?.repositories[key]?.worktrees) {
-        delete repoState.repositories[key].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: string): Promise<void> {
-    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: string,
-    message: string,
-    author?: GitAuthor
-  ): Promise<string> {
-    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.updatedAt = new Date();
-    await this.updateTaskStateByTaskId(taskId, taskState);
-
-    console.log(`Created commit ${commitHash} for task ${taskId}`);
-    return commitHash;
-  }
-
-  /**
-   * Create a new branch for a task
-   */
-  async createBranch(taskId: string, branchName: string): Promise<void> {
-    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: string,
-    targetBranch: string
-  ): Promise<RebaseResult> {
-    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 {
-      // Fetch latest changes
-      await git.fetch("origin", targetBranch);
-
-      // Perform rebase
-      await git.rebase([`origin/${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}`);
-      return { success: true };
-    } catch (error) {
-      console.error(`Rebase failed for task ${taskId}:`, 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: string,
-    targetBranch: string,
-    mode: MergeMode = "no-ff"
-  ): Promise<MergeResult> {
-    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 merge operation for local workspace task ${taskId}`
-      );
-      return { success: true, mergedCommit: "local-merge" }; // Return success for local workspaces
-    }
-
-    const git = simpleGit(taskState.worktreePath);
-
-    try {
-      // Fetch latest changes
-      await git.fetch("origin", targetBranch);
-
-      // Checkout target branch
-      await git.checkout(targetBranch);
-      await git.pull("origin", targetBranch);
-
-      // Perform merge based on mode
-      let mergeArgs: string[] = [];
-      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([taskState.branch, ...mergeArgs]);
-
-      // For squash merge, we need to commit
-      if (mode === "squash") {
-        const commitResult = await git.commit(
-          `Merge task ${taskId} (${taskState.branch})`
-        );
-        result.result = commitResult.commit;
-      }
-
-      // Update task state
-      taskState.status = "merged";
-      taskState.updatedAt = new Date();
-      await this.updateTaskStateByTaskId(taskId, taskState);
-
-      console.log(`Successfully merged task ${taskId} into ${targetBranch}`);
-      return {
-        success: true,
-        mergedCommit: result.result,
-      };
-    } catch (error) {
-      console.error(`Merge failed for task ${taskId}:`, 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: "Merge resulted in conflicts",
-        };
-      }
-
-      return {
-        success: false,
-        error: error instanceof Error ? error.message : String(error),
-      };
-    }
-  }
-
-  /**
-   * Get task Git state
-   */
-  async getTaskState(taskId: string): Promise<TaskGitState | null> {
-    for (const state of this.repoStates.values()) {
-      for (const repo of Object.values(state.repositories)) {
-        if (repo.worktrees[taskId]) {
-          return repo.worktrees[taskId];
-        }
-      }
-    }
-    return null;
-  }
-
-  /**
-   * Update task state
-   */
-  private async updateTaskState(
-    repoKey: string,
-    state: TaskGitState
-  ): Promise<void> {
-    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 {
-        const { owner, repo } = this.getRepoKey(repoKey);
-        repoState.repositories[repoKey] = {
-          owner,
-          repo,
-          controlPath: path.join(
-            this.repoBasePath,
-            "repos",
-            repoKey,
-            "control"
-          ),
-          worktrees: {},
-        };
-      }
-    }
-
-    repoState.repositories[repoKey].worktrees[state.taskId] = state;
-    await this.persistState();
-  }
-
-  /**
-   * Update task state by task ID
-   */
-  private async updateTaskStateByTaskId(
-    taskId: string,
-    state: TaskGitState
-  ): Promise<void> {
-    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(): Promise<void> {
-    try {
-      const stateData: Record<string, RepositoryState> = {};
-      for (const [key, value] of this.repoStates) {
-        stateData[key] = value;
-      }
-
-      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(): Promise<void> {
-    try {
-      const data = await fs.readFile(this.stateFilePath, "utf-8");
-      const stateData = JSON.parse(data) as Record<string, RepositoryState>;
-
-      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 as any).code !== "ENOENT") {
-        console.error("Failed to restore repository state:", error);
-      }
-      // If file doesn't exist, that's okay - we'll start fresh
-    }
-  }
-
-  /**
-   * Override parent's checkoutRepository to use worktrees for backward compatibility
-   */
-  override async checkoutRepository(
-    workspaceId: string,
-    repoUrl: string,
-    branch: string,
-    githubToken?: string
-  ): Promise<string> {
-    // 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;
-  }
-}