@akiojin/gwt 2.0.0

package/src/services/WorktreeOrchestrator.ts

@@ -0,0 +1,115 @@
+import type { WorktreeConfig } from "../worktree.js";
+import {
+  worktreeExists,
+  generateWorktreePath,
+  createWorktree,
+} from "../worktree.js";
+import { getCurrentBranch } from "../git.js";
+import chalk from "chalk";
+
+/**
+ * WorktreeService interface for dependency injection
+ */
+export interface WorktreeService {
+  worktreeExists: (branch: string) => Promise<string | null>;
+  generateWorktreePath: (repoRoot: string, branch: string) => Promise<string>;
+  createWorktree: (config: WorktreeConfig) => Promise<void>;
+}
+
+export interface EnsureWorktreeOptions {
+  baseBranch?: string;
+  isNewBranch?: boolean;
+}
+
+/**
+ * WorktreeOrchestrator - Manages worktree existence checks and creation
+ *
+ * Responsibility:
+ * - Check if worktree exists for a given branch
+ * - Create worktree if it doesn't exist
+ * - Return worktree path
+ */
+export class WorktreeOrchestrator {
+  private worktreeService: WorktreeService;
+
+  constructor(worktreeService?: WorktreeService) {
+    this.worktreeService = worktreeService || {
+      worktreeExists,
+      generateWorktreePath,
+      createWorktree,
+    };
+  }
+
+  /**
+   * Ensure worktree exists for the given branch
+   * If worktree exists, return its path
+   * If worktree doesn't exist, create it and return the path
+   *
+   * @param branch - Branch name
+   * @param repoRoot - Repository root path
+   * @param options - Creation options (base branch, new branch flag)
+   * @returns Worktree path
+   */
+  async ensureWorktree(
+    branch: string,
+    repoRoot: string,
+    options: EnsureWorktreeOptions = {},
+  ): Promise<string> {
+    const baseBranch = options.baseBranch ?? "main";
+    const isNewBranch = options.isNewBranch ?? false;
+
+    // Check if selected branch is current branch
+    const currentBranch = await getCurrentBranch();
+    if (currentBranch === branch) {
+      // Current branch selected: use repository root
+      console.log(
+        chalk.gray(
+          `   ℹ️  Current branch '${branch}' selected - using repository root`,
+        ),
+      );
+      return repoRoot;
+    }
+
+    // Check if worktree already exists
+    const existingPath = await this.worktreeService.worktreeExists(branch);
+
+    if (existingPath) {
+      return existingPath;
+    }
+
+    // Generate worktree path
+    const worktreePath = await this.worktreeService.generateWorktreePath(
+      repoRoot,
+      branch,
+    );
+
+    try {
+      // Create worktree (or branch)
+      await this.worktreeService.createWorktree({
+        branchName: branch,
+        worktreePath,
+        repoRoot,
+        isNewBranch,
+        baseBranch,
+      });
+
+      return worktreePath;
+    } catch (error: unknown) {
+      const message =
+        error instanceof Error ? error.message : String(error ?? "");
+      const normalized = message.toLowerCase();
+      const alreadyExists =
+        normalized.includes("already checked out") ||
+        normalized.includes("already exists");
+
+      if (alreadyExists) {
+        const fallbackPath = await this.worktreeService.worktreeExists(branch);
+        if (fallbackPath) {
+          return fallbackPath;
+        }
+      }
+
+      throw error;
+    }
+  }
+}

package/src/services/__tests__/BatchMergeService.test.ts

@@ -0,0 +1,518 @@
+import { describe, it, expect, vi, beforeEach, afterEach } from "vitest";
+import { BatchMergeService } from "../BatchMergeService";
+import type { BatchMergeConfig } from "../../ui/types";
+
+// Mock git module
+vi.mock("../../git", () => ({
+  fetchAllRemotes: vi.fn(),
+  getLocalBranches: vi.fn(),
+  mergeFromBranch: vi.fn(),
+  hasMergeConflict: vi.fn(),
+  abortMerge: vi.fn(),
+  getMergeStatus: vi.fn(),
+  getRepositoryRoot: vi.fn(),
+  resetToHead: vi.fn(),
+  getCurrentBranchName: vi.fn(),
+  pushBranchToRemote: vi.fn(),
+}));
+
+// Mock worktree module
+vi.mock("../../worktree", () => ({
+  listAdditionalWorktrees: vi.fn(),
+  generateWorktreePath: vi.fn(),
+  createWorktree: vi.fn(),
+}));
+
+import * as git from "../../git";
+import * as worktree from "../../worktree";
+
+// ========================================
+// BatchMergeService Tests (SPEC-ee33ca26)
+// ========================================
+
+describe("BatchMergeService", () => {
+  let service: BatchMergeService;
+
+  beforeEach(() => {
+    vi.clearAllMocks();
+    service = new BatchMergeService();
+  });
+
+  afterEach(() => {
+    vi.restoreAllMocks();
+  });
+
+  describe("Initialization (T201)", () => {
+    it("should create BatchMergeService instance", () => {
+      expect(service).toBeInstanceOf(BatchMergeService);
+    });
+
+    it("should have required methods", () => {
+      expect(typeof service.determineSourceBranch).toBe("function");
+      expect(typeof service.getTargetBranches).toBe("function");
+      expect(typeof service.ensureWorktree).toBe("function");
+      expect(typeof service.mergeBranch).toBe("function");
+      expect(typeof service.executeBatchMerge).toBe("function");
+    });
+  });
+
+  describe("determineSourceBranch (T203)", () => {
+    it("should return 'main' when main branch exists", async () => {
+      (git.getLocalBranches as ReturnType<typeof vi.fn>).mockResolvedValue([
+        {
+          name: "main",
+          type: "local",
+          branchType: "main",
+          isCurrent: false,
+        },
+        {
+          name: "develop",
+          type: "local",
+          branchType: "develop",
+          isCurrent: false,
+        },
+        {
+          name: "feature/test",
+          type: "local",
+          branchType: "feature",
+          isCurrent: true,
+        },
+      ]);
+
+      const sourceBranch = await service.determineSourceBranch();
+
+      expect(sourceBranch).toBe("main");
+    });
+
+    it("should return 'develop' when main does not exist but develop exists", async () => {
+      (git.getLocalBranches as ReturnType<typeof vi.fn>).mockResolvedValue([
+        {
+          name: "develop",
+          type: "local",
+          branchType: "develop",
+          isCurrent: false,
+        },
+        {
+          name: "feature/test",
+          type: "local",
+          branchType: "feature",
+          isCurrent: true,
+        },
+      ]);
+
+      const sourceBranch = await service.determineSourceBranch();
+
+      expect(sourceBranch).toBe("develop");
+    });
+
+    it("should return 'master' when main and develop do not exist", async () => {
+      (git.getLocalBranches as ReturnType<typeof vi.fn>).mockResolvedValue([
+        {
+          name: "master",
+          type: "local",
+          branchType: "main",
+          isCurrent: false,
+        },
+        {
+          name: "feature/test",
+          type: "local",
+          branchType: "feature",
+          isCurrent: true,
+        },
+      ]);
+
+      const sourceBranch = await service.determineSourceBranch();
+
+      expect(sourceBranch).toBe("master");
+    });
+
+    it("should throw error when no source branch found", async () => {
+      (git.getLocalBranches as ReturnType<typeof vi.fn>).mockResolvedValue([
+        {
+          name: "feature/test",
+          type: "local",
+          branchType: "feature",
+          isCurrent: true,
+        },
+      ]);
+
+      await expect(service.determineSourceBranch()).rejects.toThrow(
+        "Unable to determine source branch",
+      );
+    });
+  });
+
+  describe("getTargetBranches (T205)", () => {
+    it("should return all local branches excluding main, develop, master", async () => {
+      (git.getLocalBranches as ReturnType<typeof vi.fn>).mockResolvedValue([
+        {
+          name: "main",
+          type: "local",
+          branchType: "main",
+          isCurrent: false,
+        },
+        {
+          name: "develop",
+          type: "local",
+          branchType: "develop",
+          isCurrent: false,
+        },
+        {
+          name: "feature/a",
+          type: "local",
+          branchType: "feature",
+          isCurrent: false,
+        },
+        {
+          name: "feature/b",
+          type: "local",
+          branchType: "feature",
+          isCurrent: true,
+        },
+        {
+          name: "hotfix/c",
+          type: "local",
+          branchType: "hotfix",
+          isCurrent: false,
+        },
+      ]);
+
+      const targetBranches = await service.getTargetBranches();
+
+      expect(targetBranches).toEqual(["feature/a", "feature/b", "hotfix/c"]);
+      expect(targetBranches).not.toContain("main");
+      expect(targetBranches).not.toContain("develop");
+    });
+
+    it("should return empty array when only main/develop/master exist", async () => {
+      (git.getLocalBranches as ReturnType<typeof vi.fn>).mockResolvedValue([
+        {
+          name: "main",
+          type: "local",
+          branchType: "main",
+          isCurrent: true,
+        },
+        {
+          name: "develop",
+          type: "local",
+          branchType: "develop",
+          isCurrent: false,
+        },
+      ]);
+
+      const targetBranches = await service.getTargetBranches();
+
+      expect(targetBranches).toEqual([]);
+    });
+  });
+
+  describe("ensureWorktree (T207)", () => {
+    it("should return existing worktree path if worktree exists", async () => {
+      (
+        worktree.listAdditionalWorktrees as ReturnType<typeof vi.fn>
+      ).mockResolvedValue([
+        {
+          path: "/repo/.worktrees/feature-a",
+          locked: false,
+          prunable: false,
+          isAccessible: true,
+        },
+      ]);
+
+      const worktreePath = await service.ensureWorktree("feature/a");
+
+      expect(worktreePath).toBe("/repo/.worktrees/feature-a");
+      expect(worktree.createWorktree).not.toHaveBeenCalled();
+    });
+
+    it("should create worktree if it does not exist", async () => {
+      (
+        worktree.listAdditionalWorktrees as ReturnType<typeof vi.fn>
+      ).mockResolvedValue([]);
+      (git.getRepositoryRoot as ReturnType<typeof vi.fn>).mockResolvedValue(
+        "/repo",
+      );
+      (
+        worktree.generateWorktreePath as ReturnType<typeof vi.fn>
+      ).mockResolvedValue("/repo/.worktrees/feature-b");
+      (worktree.createWorktree as ReturnType<typeof vi.fn>).mockResolvedValue();
+
+      const worktreePath = await service.ensureWorktree("feature/b");
+
+      expect(worktreePath).toBe("/repo/.worktrees/feature-b");
+      expect(worktree.createWorktree).toHaveBeenCalledWith({
+        branchName: "feature/b",
+        worktreePath: "/repo/.worktrees/feature-b",
+        repoRoot: "/repo",
+        isNewBranch: false,
+        baseBranch: "",
+      });
+    });
+  });
+
+  describe("mergeBranch (T209-T212)", () => {
+    const config: BatchMergeConfig = {
+      sourceBranch: "main",
+      targetBranches: ["feature/a"],
+      dryRun: false,
+      autoPush: false,
+    };
+
+    beforeEach(() => {
+      (
+        worktree.listAdditionalWorktrees as ReturnType<typeof vi.fn>
+      ).mockResolvedValue([
+        {
+          path: "/repo/.worktrees/feature-a",
+          locked: false,
+          prunable: false,
+        },
+      ]);
+    });
+
+    it("should successfully merge without conflicts", async () => {
+      (git.mergeFromBranch as ReturnType<typeof vi.fn>).mockResolvedValue();
+      (git.hasMergeConflict as ReturnType<typeof vi.fn>).mockResolvedValue(
+        false,
+      );
+
+      const status = await service.mergeBranch("feature/a", "main", config);
+
+      expect(status.branchName).toBe("feature/a");
+      expect(status.status).toBe("success");
+      expect(status.worktreeCreated).toBe(false);
+      expect(git.mergeFromBranch).toHaveBeenCalledWith(
+        "/repo/.worktrees/feature-a",
+        "main",
+        false,
+      );
+    });
+
+    it("should skip branch on merge conflict", async () => {
+      (git.mergeFromBranch as ReturnType<typeof vi.fn>).mockRejectedValue(
+        new Error("Merge conflict"),
+      );
+      (git.hasMergeConflict as ReturnType<typeof vi.fn>).mockResolvedValue(
+        true,
+      );
+      (git.abortMerge as ReturnType<typeof vi.fn>).mockResolvedValue();
+
+      const status = await service.mergeBranch("feature/a", "main", config);
+
+      expect(status.branchName).toBe("feature/a");
+      expect(status.status).toBe("skipped");
+      expect(git.abortMerge).toHaveBeenCalled();
+    });
+
+    it("should handle other errors as failed", async () => {
+      (git.mergeFromBranch as ReturnType<typeof vi.fn>).mockRejectedValue(
+        new Error("Network error"),
+      );
+      (git.hasMergeConflict as ReturnType<typeof vi.fn>).mockResolvedValue(
+        false,
+      );
+
+      const status = await service.mergeBranch("feature/a", "main", config);
+
+      expect(status.branchName).toBe("feature/a");
+      expect(status.status).toBe("failed");
+      expect(status.error).toContain("Network error");
+    });
+  });
+
+  describe("mergeBranch - Dry-run mode (T303-T304)", () => {
+    const dryRunConfig: BatchMergeConfig = {
+      sourceBranch: "main",
+      targetBranches: ["feature/a"],
+      dryRun: true,
+      autoPush: false,
+    };
+
+    beforeEach(() => {
+      (
+        worktree.listAdditionalWorktrees as ReturnType<typeof vi.fn>
+      ).mockResolvedValue([
+        {
+          path: "/repo/.worktrees/feature-a",
+          locked: false,
+          prunable: false,
+        },
+      ]);
+    });
+
+    it("should rollback with resetToHead after successful dry-run merge", async () => {
+      (git.mergeFromBranch as ReturnType<typeof vi.fn>).mockResolvedValue();
+      (git.hasMergeConflict as ReturnType<typeof vi.fn>).mockResolvedValue(
+        false,
+      );
+      (git.resetToHead as ReturnType<typeof vi.fn>).mockResolvedValue();
+
+      const status = await service.mergeBranch(
+        "feature/a",
+        "main",
+        dryRunConfig,
+      );
+
+      expect(status.branchName).toBe("feature/a");
+      expect(status.status).toBe("success");
+      expect(git.mergeFromBranch).toHaveBeenCalledWith(
+        "/repo/.worktrees/feature-a",
+        "main",
+        true,
+      );
+      expect(git.resetToHead).toHaveBeenCalledWith(
+        "/repo/.worktrees/feature-a",
+      );
+    });
+
+    it("should rollback with abortMerge after dry-run merge conflict", async () => {
+      (git.mergeFromBranch as ReturnType<typeof vi.fn>).mockRejectedValue(
+        new Error("CONFLICT (content)"),
+      );
+      (git.hasMergeConflict as ReturnType<typeof vi.fn>).mockResolvedValue(
+        true,
+      );
+      (git.abortMerge as ReturnType<typeof vi.fn>).mockResolvedValue();
+
+      const status = await service.mergeBranch(
+        "feature/a",
+        "main",
+        dryRunConfig,
+      );
+
+      expect(status.branchName).toBe("feature/a");
+      expect(status.status).toBe("skipped");
+      expect(git.abortMerge).toHaveBeenCalledWith("/repo/.worktrees/feature-a");
+      expect(git.resetToHead).not.toHaveBeenCalled();
+    });
+  });
+
+  describe("mergeBranch - Auto-push mode (T401-T404)", () => {
+    const autoPushConfig: BatchMergeConfig = {
+      sourceBranch: "main",
+      targetBranches: ["feature/a"],
+      dryRun: false,
+      autoPush: true,
+      remote: "origin",
+    };
+
+    beforeEach(() => {
+      (
+        worktree.listAdditionalWorktrees as ReturnType<typeof vi.fn>
+      ).mockResolvedValue([
+        {
+          path: "/repo/.worktrees/feature-a",
+          locked: false,
+          prunable: false,
+        },
+      ]);
+    });
+
+    it("should push successfully after merge when autoPush is enabled", async () => {
+      (git.mergeFromBranch as ReturnType<typeof vi.fn>).mockResolvedValue();
+      (git.hasMergeConflict as ReturnType<typeof vi.fn>).mockResolvedValue(
+        false,
+      );
+      (git.getCurrentBranchName as ReturnType<typeof vi.fn>).mockResolvedValue(
+        "feature/a",
+      );
+      (git.pushBranchToRemote as ReturnType<typeof vi.fn>).mockResolvedValue();
+
+      const status = await service.mergeBranch(
+        "feature/a",
+        "main",
+        autoPushConfig,
+      );
+
+      expect(status.branchName).toBe("feature/a");
+      expect(status.status).toBe("success");
+      expect(status.pushStatus).toBe("success");
+      expect(git.pushBranchToRemote).toHaveBeenCalledWith(
+        "/repo/.worktrees/feature-a",
+        "feature/a",
+        "origin",
+      );
+    });
+
+    it("should handle push failure without failing merge", async () => {
+      (git.mergeFromBranch as ReturnType<typeof vi.fn>).mockResolvedValue();
+      (git.hasMergeConflict as ReturnType<typeof vi.fn>).mockResolvedValue(
+        false,
+      );
+      (git.getCurrentBranchName as ReturnType<typeof vi.fn>).mockResolvedValue(
+        "feature/a",
+      );
+      (git.pushBranchToRemote as ReturnType<typeof vi.fn>).mockRejectedValue(
+        new Error("Push failed: permission denied"),
+      );
+
+      const status = await service.mergeBranch(
+        "feature/a",
+        "main",
+        autoPushConfig,
+      );
+
+      expect(status.branchName).toBe("feature/a");
+      expect(status.status).toBe("success");
+      expect(status.pushStatus).toBe("failed");
+    });
+
+    it("should not push when autoPush is false", async () => {
+      const noPushConfig = { ...autoPushConfig, autoPush: false };
+      (git.mergeFromBranch as ReturnType<typeof vi.fn>).mockResolvedValue();
+      (git.hasMergeConflict as ReturnType<typeof vi.fn>).mockResolvedValue(
+        false,
+      );
+
+      const status = await service.mergeBranch(
+        "feature/a",
+        "main",
+        noPushConfig,
+      );
+
+      expect(status.branchName).toBe("feature/a");
+      expect(status.status).toBe("success");
+      expect(status.pushStatus).toBe("not_executed");
+      expect(git.pushBranchToRemote).not.toHaveBeenCalled();
+    });
+  });
+
+  describe("executeBatchMerge (T213)", () => {
+    it("should execute batch merge for all target branches", async () => {
+      const config: BatchMergeConfig = {
+        sourceBranch: "main",
+        targetBranches: ["feature/a", "feature/b"],
+        dryRun: false,
+        autoPush: false,
+      };
+
+      (git.fetchAllRemotes as ReturnType<typeof vi.fn>).mockResolvedValue();
+      (git.getRepositoryRoot as ReturnType<typeof vi.fn>).mockResolvedValue(
+        "/repo",
+      );
+      (
+        worktree.listAdditionalWorktrees as ReturnType<typeof vi.fn>
+      ).mockResolvedValue([]);
+      (worktree.generateWorktreePath as ReturnType<typeof vi.fn>)
+        .mockResolvedValueOnce("/repo/.worktrees/feature-a")
+        .mockResolvedValueOnce("/repo/.worktrees/feature-b");
+      (worktree.createWorktree as ReturnType<typeof vi.fn>).mockResolvedValue();
+      (git.mergeFromBranch as ReturnType<typeof vi.fn>).mockResolvedValue();
+      (git.hasMergeConflict as ReturnType<typeof vi.fn>).mockResolvedValue(
+        false,
+      );
+
+      const progressUpdates: BatchMergeProgress[] = [];
+      const result = await service.executeBatchMerge(config, (progress) => {
+        progressUpdates.push(progress);
+      });
+
+      expect(result.statuses).toHaveLength(2);
+      expect(result.summary.totalCount).toBe(2);
+      expect(result.summary.successCount).toBeGreaterThanOrEqual(0);
+      expect(result.cancelled).toBe(false);
+      expect(progressUpdates.length).toBeGreaterThan(0);
+      expect(git.fetchAllRemotes).toHaveBeenCalled();
+    });
+  });
+});