@akiojin/gwt 2.0.0

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

@@ -0,0 +1,258 @@
+import { describe, it, expect, vi, beforeEach } from "vitest";
+import {
+  WorktreeOrchestrator,
+  type WorktreeService,
+} from "../WorktreeOrchestrator.js";
+import * as git from "../../git.js";
+
+// Mock git.getCurrentBranch
+vi.mock("../../git.js", () => ({
+  getCurrentBranch: vi.fn(),
+}));
+
+describe("WorktreeOrchestrator", () => {
+  let orchestrator: WorktreeOrchestrator;
+  let mockWorktreeService: WorktreeService;
+  const mockRepoRoot = "/mock/repo";
+  const mockBranch = "feature-test";
+  const mockWorktreePath = "/mock/repo/.git/worktree/feature-test";
+
+  beforeEach(() => {
+    // Create mock service without vi.mock()
+    mockWorktreeService = {
+      worktreeExists: vi.fn(),
+      generateWorktreePath: vi.fn(),
+      createWorktree: vi.fn(),
+    };
+    orchestrator = new WorktreeOrchestrator(mockWorktreeService);
+  });
+
+  describe("ensureWorktree", () => {
+    it("should return existing worktree path if worktree exists", async () => {
+      // Arrange
+      (mockWorktreeService.worktreeExists as any).mockResolvedValue(
+        mockWorktreePath,
+      );
+
+      // Act
+      const result = await orchestrator.ensureWorktree(
+        mockBranch,
+        mockRepoRoot,
+      );
+
+      // Assert
+      expect(result).toBe(mockWorktreePath);
+      expect(mockWorktreeService.worktreeExists).toHaveBeenCalledWith(
+        mockBranch,
+      );
+      expect(mockWorktreeService.generateWorktreePath).not.toHaveBeenCalled();
+      expect(mockWorktreeService.createWorktree).not.toHaveBeenCalled();
+    });
+
+    it("should create new worktree if it does not exist", async () => {
+      // Arrange
+      (mockWorktreeService.worktreeExists as any).mockResolvedValue(null);
+      (mockWorktreeService.generateWorktreePath as any).mockResolvedValue(
+        mockWorktreePath,
+      );
+      (mockWorktreeService.createWorktree as any).mockResolvedValue(undefined);
+
+      // Act
+      const result = await orchestrator.ensureWorktree(
+        mockBranch,
+        mockRepoRoot,
+      );
+
+      // Assert
+      expect(result).toBe(mockWorktreePath);
+      expect(mockWorktreeService.worktreeExists).toHaveBeenCalledWith(
+        mockBranch,
+      );
+      expect(mockWorktreeService.generateWorktreePath).toHaveBeenCalledWith(
+        mockRepoRoot,
+        mockBranch,
+      );
+      expect(mockWorktreeService.createWorktree).toHaveBeenCalledWith({
+        branchName: mockBranch,
+        worktreePath: mockWorktreePath,
+        repoRoot: mockRepoRoot,
+        isNewBranch: false,
+        baseBranch: "main",
+      });
+    });
+
+    it("should use custom base branch when provided", async () => {
+      // Arrange
+      (mockWorktreeService.worktreeExists as any).mockResolvedValue(null);
+      (mockWorktreeService.generateWorktreePath as any).mockResolvedValue(
+        mockWorktreePath,
+      );
+      (mockWorktreeService.createWorktree as any).mockResolvedValue(undefined);
+      const customBaseBranch = "develop";
+
+      // Act
+      const result = await orchestrator.ensureWorktree(
+        mockBranch,
+        mockRepoRoot,
+        {
+          baseBranch: customBaseBranch,
+        },
+      );
+
+      // Assert
+      expect(result).toBe(mockWorktreePath);
+      expect(mockWorktreeService.createWorktree).toHaveBeenCalledWith({
+        branchName: mockBranch,
+        worktreePath: mockWorktreePath,
+        repoRoot: mockRepoRoot,
+        isNewBranch: false,
+        baseBranch: customBaseBranch,
+      });
+    });
+
+    it("should mark worktree creation as new branch when requested", async () => {
+      (mockWorktreeService.worktreeExists as any).mockResolvedValue(null);
+      (mockWorktreeService.generateWorktreePath as any).mockResolvedValue(
+        mockWorktreePath,
+      );
+
+      (mockWorktreeService.createWorktree as any).mockResolvedValue(undefined);
+
+      const result = await orchestrator.ensureWorktree(
+        mockBranch,
+        mockRepoRoot,
+        {
+          baseBranch: "origin/feature-test",
+          isNewBranch: true,
+        },
+      );
+
+      expect(result).toBe(mockWorktreePath);
+      expect(mockWorktreeService.createWorktree).toHaveBeenCalledWith({
+        branchName: mockBranch,
+        worktreePath: mockWorktreePath,
+        repoRoot: mockRepoRoot,
+        isNewBranch: true,
+        baseBranch: "origin/feature-test",
+      });
+    });
+
+    it("should throw error if worktree creation fails", async () => {
+      // Arrange
+      (mockWorktreeService.worktreeExists as any).mockResolvedValue(null);
+      (mockWorktreeService.generateWorktreePath as any).mockResolvedValue(
+        mockWorktreePath,
+      );
+      const mockError = new Error("Failed to create worktree");
+      (mockWorktreeService.createWorktree as any).mockRejectedValue(mockError);
+
+      // Act & Assert
+      await expect(
+        orchestrator.ensureWorktree(mockBranch, mockRepoRoot),
+      ).rejects.toThrow("Failed to create worktree");
+    });
+
+    it("should reuse existing worktree if creation reports branch already checked out", async () => {
+      const existingPath = "/mock/repo/.git/worktree/feature-test-existing";
+
+      (mockWorktreeService.worktreeExists as any)
+        .mockResolvedValueOnce(null)
+        .mockResolvedValueOnce(existingPath);
+
+      (mockWorktreeService.generateWorktreePath as any).mockResolvedValue(
+        mockWorktreePath,
+      );
+
+      const alreadyCheckedOutError = new Error(
+        "fatal: 'feature-test' is already checked out at '/mock/repo/.git/worktree/feature-test-existing'",
+      );
+
+      (mockWorktreeService.createWorktree as any).mockRejectedValue(
+        alreadyCheckedOutError,
+      );
+
+      const result = await orchestrator.ensureWorktree(
+        mockBranch,
+        mockRepoRoot,
+      );
+
+      expect(result).toBe(existingPath);
+      expect(mockWorktreeService.worktreeExists).toHaveBeenCalledTimes(2);
+      expect(mockWorktreeService.createWorktree).toHaveBeenCalledTimes(1);
+    });
+
+    describe("current branch handling", () => {
+      it("should return repository root when current branch is selected", async () => {
+        // Arrange
+        const currentBranch = "main";
+        (git.getCurrentBranch as any).mockResolvedValue(currentBranch);
+
+        // Act
+        const result = await orchestrator.ensureWorktree(
+          currentBranch,
+          mockRepoRoot,
+        );
+
+        // Assert
+        expect(result).toBe(mockRepoRoot);
+        expect(git.getCurrentBranch).toHaveBeenCalled();
+        expect(mockWorktreeService.worktreeExists).not.toHaveBeenCalled();
+        expect(mockWorktreeService.createWorktree).not.toHaveBeenCalled();
+      });
+
+      it("should create worktree when non-current branch is selected", async () => {
+        // Arrange
+        const currentBranch = "main";
+        const otherBranch = "feature-test";
+        (git.getCurrentBranch as any).mockResolvedValue(currentBranch);
+        (mockWorktreeService.worktreeExists as any).mockResolvedValue(null);
+        (mockWorktreeService.generateWorktreePath as any).mockResolvedValue(
+          mockWorktreePath,
+        );
+        (mockWorktreeService.createWorktree as any).mockResolvedValue(
+          undefined,
+        );
+
+        // Act
+        const result = await orchestrator.ensureWorktree(
+          otherBranch,
+          mockRepoRoot,
+        );
+
+        // Assert
+        expect(result).toBe(mockWorktreePath);
+        expect(git.getCurrentBranch).toHaveBeenCalled();
+        expect(mockWorktreeService.worktreeExists).toHaveBeenCalledWith(
+          otherBranch,
+        );
+        expect(mockWorktreeService.createWorktree).toHaveBeenCalled();
+      });
+
+      it("should fallback to normal flow when getCurrentBranch returns null", async () => {
+        // Arrange
+        (git.getCurrentBranch as any).mockResolvedValue(null);
+        (mockWorktreeService.worktreeExists as any).mockResolvedValue(null);
+        (mockWorktreeService.generateWorktreePath as any).mockResolvedValue(
+          mockWorktreePath,
+        );
+        (mockWorktreeService.createWorktree as any).mockResolvedValue(
+          undefined,
+        );
+
+        // Act
+        const result = await orchestrator.ensureWorktree(
+          mockBranch,
+          mockRepoRoot,
+        );
+
+        // Assert
+        expect(result).toBe(mockWorktreePath);
+        expect(git.getCurrentBranch).toHaveBeenCalled();
+        expect(mockWorktreeService.worktreeExists).toHaveBeenCalledWith(
+          mockBranch,
+        );
+        expect(mockWorktreeService.createWorktree).toHaveBeenCalled();
+      });
+    });
+  });
+});

package/src/services/dependency-installer.ts

@@ -0,0 +1,199 @@
+import path from "node:path";
+import fs from "node:fs/promises";
+import { execa } from "execa";
+import { startSpinner } from "../utils/spinner.js";
+
+export type PackageManager = "bun" | "pnpm" | "npm";
+
+interface PackageManagerCandidate {
+  manager: PackageManager;
+  lockfile: string;
+  command: [string, ...string[]];
+}
+
+interface DetectedPackageManager {
+  manager: PackageManager;
+  lockfile: string;
+  command: [string, ...string[]];
+}
+
+export type DependencySkipReason =
+  | "missing-lockfile"
+  | "missing-binary"
+  | "install-failed"
+  | "lockfile-access-error"
+  | "unknown-error";
+
+export type DependencyInstallResult =
+  | {
+      skipped: false;
+      manager: PackageManager;
+      lockfile: string;
+    }
+  | {
+      skipped: true;
+      manager: PackageManager | null;
+      lockfile: string | null;
+      reason: DependencySkipReason;
+      message?: string;
+    };
+
+export class DependencyInstallError extends Error {
+  constructor(
+    message: string,
+    public cause?: unknown,
+  ) {
+    super(message);
+    this.name = "DependencyInstallError";
+  }
+}
+
+const INSTALL_CANDIDATES: PackageManagerCandidate[] = [
+  {
+    manager: "bun",
+    lockfile: "bun.lock",
+    command: ["bun", "install", "--frozen-lockfile"],
+  },
+  {
+    manager: "pnpm",
+    lockfile: "pnpm-lock.yaml",
+    command: ["pnpm", "install", "--frozen-lockfile"],
+  },
+  {
+    manager: "npm",
+    lockfile: "package-lock.json",
+    command: ["npm", "ci"],
+  },
+  {
+    manager: "npm",
+    lockfile: "package.json",
+    command: ["npm", "install"],
+  },
+];
+
+async function fileExists(targetPath: string): Promise<boolean> {
+  try {
+    await fs.access(targetPath);
+    return true;
+  } catch (error) {
+    const code = (error as NodeJS.ErrnoException)?.code;
+    if (code === "ENOENT") {
+      return false;
+    }
+    throw new DependencyInstallError(
+      `Lockfile access failed: ${targetPath} (${code ?? "unknown"})`,
+      error,
+    );
+  }
+}
+
+export async function detectPackageManager(
+  worktreePath: string,
+): Promise<DetectedPackageManager | null> {
+  const normalized = path.resolve(worktreePath);
+
+  for (const candidate of INSTALL_CANDIDATES) {
+    const fullPath = path.join(normalized, candidate.lockfile);
+    if (await fileExists(fullPath)) {
+      return {
+        manager: candidate.manager,
+        lockfile: fullPath,
+        command: candidate.command,
+      };
+    }
+  }
+
+  return null;
+}
+
+export async function installDependenciesForWorktree(
+  worktreePath: string,
+): Promise<DependencyInstallResult> {
+  let detection: DetectedPackageManager | null = null;
+
+  try {
+    detection = await detectPackageManager(worktreePath);
+  } catch (error) {
+    if (error instanceof DependencyInstallError) {
+      return {
+        skipped: true,
+        manager: null,
+        lockfile: null,
+        reason: "lockfile-access-error",
+        message: error.message,
+      };
+    }
+
+    return {
+      skipped: true,
+      manager: null,
+      lockfile: null,
+      reason: "unknown-error",
+      message: error instanceof Error ? error.message : String(error),
+    };
+  }
+
+  if (!detection) {
+    return {
+      skipped: true,
+      manager: null,
+      lockfile: null,
+      reason: "missing-lockfile",
+    };
+  }
+
+  const [binary, ...args] = detection.command;
+
+  const spinner = startSpinner(
+    `Installing dependencies via ${detection.manager} (${path.basename(detection.lockfile)})`,
+  );
+
+  try {
+    await execa(binary, args, {
+      cwd: worktreePath,
+      stdout: "inherit",
+      stderr: "inherit",
+    });
+  } catch (error) {
+    const code = (error as NodeJS.ErrnoException)?.code;
+
+    if (code === "ENOENT") {
+      console.warn(
+        `Package manager '${binary}' was not found; skipping automatic install.`,
+      );
+      return {
+        skipped: true,
+        manager: detection.manager,
+        lockfile: detection.lockfile,
+        reason: "missing-binary",
+      };
+    }
+
+    const messageParts = [
+      `Dependency installation failed (${detection.manager}).`,
+      `Command: ${binary} ${args.join(" ")}`,
+    ];
+
+    const stderr = (error as { stderr?: string })?.stderr;
+    if (stderr) {
+      messageParts.push(stderr.trim());
+    }
+    const failureMessage = messageParts.join("\n");
+
+    return {
+      skipped: true,
+      manager: detection.manager,
+      lockfile: detection.lockfile,
+      reason: "install-failed",
+      message: failureMessage,
+    };
+  } finally {
+    spinner();
+  }
+
+  return {
+    skipped: false,
+    manager: detection.manager,
+    lockfile: detection.lockfile,
+  };
+}

package/src/services/git.service.ts

@@ -0,0 +1,113 @@
+import { GitRepository } from "../repositories/git.repository.js";
+import { BranchInfo } from "../cli/ui/types.js";
+
+/**
+ * Git操作のビジネスロジックを管理するService
+ */
+export class GitService {
+  constructor(private readonly repository: GitRepository) {}
+
+  async isValidRepository(): Promise<boolean> {
+    return await this.repository.isRepository();
+  }
+
+  async getAllBranches(): Promise<BranchInfo[]> {
+    const [localBranches, remoteBranches, currentBranch] = await Promise.all([
+      this.getLocalBranchesInfo(),
+      this.getRemoteBranchesInfo(),
+      this.repository.getCurrentBranch(),
+    ]);
+
+    // 現在のブランチ情報を設定
+    if (currentBranch) {
+      localBranches.forEach((branch) => {
+        if (branch.name === currentBranch) {
+          branch.isCurrent = true;
+        }
+      });
+    }
+
+    return [...localBranches, ...remoteBranches];
+  }
+
+  private async getLocalBranchesInfo(): Promise<BranchInfo[]> {
+    const branches = await this.repository.getBranches({ remote: false });
+    return branches.map((name) => ({
+      name,
+      type: "local" as const,
+      branchType: this.getBranchType(name),
+      isCurrent: false,
+    }));
+  }
+
+  private async getRemoteBranchesInfo(): Promise<BranchInfo[]> {
+    const branches = await this.repository.getBranches({ remote: true });
+    return branches.map((name) => ({
+      name,
+      type: "remote" as const,
+      branchType: this.getBranchType(name.replace(/^origin\//, "")),
+      isCurrent: false,
+    }));
+  }
+
+  private getBranchType(branchName: string): BranchInfo["branchType"] {
+    if (branchName.startsWith("feature/")) return "feature";
+    if (branchName.startsWith("hotfix/")) return "hotfix";
+    if (branchName.startsWith("release/")) return "release";
+    if (branchName === "main" || branchName === "master") return "main";
+    if (branchName === "develop" || branchName === "dev") return "develop";
+    return "other";
+  }
+
+  async createFeatureBranch(
+    taskName: string,
+    baseBranch: string,
+  ): Promise<string> {
+    const branchName = `feature/${taskName}`;
+    await this.repository.createBranch(branchName, baseBranch);
+    return branchName;
+  }
+
+  async deleteBranch(
+    branchName: string,
+    options?: {
+      force?: boolean;
+      remote?: boolean;
+    },
+  ): Promise<void> {
+    if (options?.remote) {
+      await this.repository.deleteRemoteBranch(branchName);
+    } else {
+      await this.repository.deleteBranch(branchName, options?.force);
+    }
+  }
+
+  async hasUncommittedChanges(workdir?: string): Promise<boolean> {
+    return await this.repository.hasChanges(workdir);
+  }
+
+  async getChangedFilesCount(workdir?: string): Promise<number> {
+    return await this.repository.getChangedFilesCount(workdir);
+  }
+
+  async commitAllChanges(message: string): Promise<void> {
+    await this.repository.add(".");
+    await this.repository.commit(message, { all: true });
+  }
+
+  async pushChanges(branchName: string): Promise<void> {
+    await this.repository.push({ upstream: true, branch: branchName });
+  }
+
+  async stashChanges(message?: string): Promise<void> {
+    await this.repository.stash(message);
+  }
+
+  async discardAllChanges(): Promise<void> {
+    await this.repository.checkout(".");
+  }
+
+  async fetchRemoteUpdates(): Promise<void> {
+    await this.repository.fetch({ all: true, prune: true });
+  }
+}

package/src/services/github.service.ts

@@ -0,0 +1,61 @@
+import { GitHubRepository } from "../repositories/github.repository.js";
+import type { PullRequest, MergedPullRequest } from "../cli/ui/types.js";
+
+/**
+ * GitHub操作のビジネスロジックを管理するService
+ */
+export class GitHubService {
+  constructor(private readonly repository: GitHubRepository) {}
+
+  async isAvailable(): Promise<boolean> {
+    return await this.repository.isAvailable();
+  }
+
+  async checkAuthentication(): Promise<boolean> {
+    return await this.repository.isAuthenticated();
+  }
+
+  async getMergedPullRequests(): Promise<MergedPullRequest[]> {
+    // リモート情報を更新
+    await this.repository.fetchRemoteUpdates();
+
+    const prs = await this.repository.fetchPullRequests({
+      state: "merged",
+      limit: 100,
+    });
+
+    return prs
+      .filter((pr) => pr.mergedAt !== null)
+      .map((pr) => ({
+        number: pr.number,
+        title: pr.title,
+        branch: pr.headRefName,
+        mergedAt: pr.mergedAt as string, // filterで null を除外済み
+        author: pr.author?.login || "unknown",
+      }));
+  }
+
+  async getPullRequestByBranch(
+    branchName: string,
+  ): Promise<PullRequest | null> {
+    const prs = await this.repository.fetchPullRequests({
+      head: branchName,
+      state: "all",
+      limit: 1,
+    });
+
+    if (prs.length === 0 || !prs[0]) {
+      return null;
+    }
+
+    const pr = prs[0];
+    return {
+      number: pr.number,
+      title: pr.title,
+      state: pr.state as "OPEN" | "CLOSED" | "MERGED",
+      branch: pr.headRefName,
+      mergedAt: pr.mergedAt,
+      author: pr.author?.login || "unknown",
+    };
+  }
+}

package/src/services/worktree.service.ts

@@ -0,0 +1,66 @@
+import path from "node:path";
+import { WorktreeRepository } from "../repositories/worktree.repository.js";
+import { GitRepository } from "../repositories/git.repository.js";
+import { WorktreeInfo } from "../worktree.js";
+import { WorktreeConfig } from "../cli/ui/types.js";
+
+/**
+ * Worktree操作のビジネスロジックを管理するService
+ */
+export class WorktreeService {
+  constructor(
+    private readonly worktreeRepository: WorktreeRepository,
+    private readonly gitRepository: GitRepository,
+  ) {}
+
+  async listAdditionalWorktrees(): Promise<WorktreeInfo[]> {
+    const [allWorktrees, repoRoot] = await Promise.all([
+      this.listAllWorktrees(),
+      this.gitRepository.getRepositoryRoot(),
+    ]);
+
+    // メインworktree（リポジトリルート）を除外
+    return allWorktrees.filter((w) => w.path !== repoRoot);
+  }
+
+  async listAllWorktrees(): Promise<WorktreeInfo[]> {
+    const worktrees = await this.worktreeRepository.list();
+    return worktrees.map((w) => ({
+      path: w.path,
+      branch: w.branch,
+      head: w.head,
+    }));
+  }
+
+  async createWorktree(config: WorktreeConfig): Promise<void> {
+    await this.worktreeRepository.add(config.worktreePath, config.branchName);
+  }
+
+  async removeWorktree(worktreePath: string, force = false): Promise<void> {
+    await this.worktreeRepository.remove(worktreePath, force);
+  }
+
+  async getWorktreeByBranch(
+    branchName: string,
+  ): Promise<WorktreeInfo | undefined> {
+    const worktrees = await this.listAllWorktrees();
+    return worktrees.find((w) => w.branch === branchName);
+  }
+
+  async getRecommendedWorktreePath(branchName: string): Promise<string> {
+    const repoRoot = await this.gitRepository.getRepositoryRoot();
+    const repoName = path.basename(repoRoot);
+    const parentDir = path.dirname(repoRoot);
+
+    // ブランチ名からworktreeパスを生成
+    const safeBranchName = branchName
+      .replace(/\//g, "-")
+      .replace(/[^a-zA-Z0-9-_]/g, "");
+
+    return path.join(parentDir, `${repoName}-${safeBranchName}`);
+  }
+
+  async prune(): Promise<void> {
+    await this.worktreeRepository.prune();
+  }
+}