@akiojin/gwt 2.0.0

package/src/launcher.ts

@@ -0,0 +1,142 @@
+/**
+ * カスタムツール起動機能
+ *
+ * カスタムAIツールの起動処理を管理します。
+ * 3つの実行タイプ（path, bunx, command）をサポートします。
+ */
+
+import { execa } from "execa";
+import type { CustomAITool, LaunchOptions } from "./types/tools.js";
+
+/**
+ * コマンド名をPATH環境変数から解決
+ *
+ * Unix/Linuxではwhichコマンド、Windowsではwhereコマンドを使用して、
+ * コマンド名を絶対パスに解決します。
+ *
+ * @param commandName - 解決するコマンド名
+ * @returns コマンドの絶対パス
+ * @throws コマンドが見つからない場合
+ */
+export async function resolveCommand(commandName: string): Promise<string> {
+  const whichCommand = process.platform === "win32" ? "where" : "which";
+
+  try {
+    const result = await execa(whichCommand, [commandName]);
+
+    // where（Windows）は複数行返す可能性があるため、最初の行のみ取得
+    const resolvedPath = (result.stdout.split("\n")[0] ?? "").trim();
+
+    if (!resolvedPath) {
+      throw new Error(
+        `Command "${commandName}" not found in PATH.\n` +
+          `Please ensure the command is installed and available in your PATH environment variable.`,
+      );
+    }
+
+    return resolvedPath;
+  } catch (error) {
+    // which/whereコマンド自体が失敗した場合
+    if (error instanceof Error) {
+      throw new Error(
+        `Failed to resolve command "${commandName}".\n` +
+          `Error: ${error.message}\n` +
+          `Please ensure the command is installed and available in your PATH environment variable.`,
+      );
+    }
+    throw error;
+  }
+}
+
+/**
+ * 引数配列を構築
+ *
+ * defaultArgs + modeArgs[mode] + extraArgs の順で引数を結合します。
+ * 未定義のフィールドは空配列として扱います。
+ *
+ * @param tool - カスタムツール定義
+ * @param options - 起動オプション
+ * @returns 結合された引数配列
+ */
+function buildArgs(tool: CustomAITool, options: LaunchOptions): string[] {
+  const args: string[] = [];
+
+  // 1. defaultArgs
+  if (tool.defaultArgs) {
+    args.push(...tool.defaultArgs);
+  }
+
+  // 2. modeArgs[mode]
+  const mode = options.mode || "normal";
+  const modeArgs = tool.modeArgs[mode];
+  if (modeArgs) {
+    args.push(...modeArgs);
+  }
+
+  // 3. extraArgs
+  if (options.extraArgs) {
+    args.push(...options.extraArgs);
+  }
+
+  return args;
+}
+
+/**
+ * カスタムAIツールを起動
+ *
+ * ツールの実行タイプ（path/bunx/command）に応じて適切な方法で起動します。
+ * stdio: "inherit" で起動するため、ツールの入出力は親プロセスに継承されます。
+ *
+ * @param tool - カスタムツール定義
+ * @param options - 起動オプション
+ * @throws 起動に失敗した場合
+ */
+export async function launchCustomAITool(
+  tool: CustomAITool,
+  options: LaunchOptions = {},
+): Promise<void> {
+  const args = buildArgs(tool, options);
+
+  const env = {
+    ...process.env,
+    ...(options.sharedEnv ?? {}),
+    ...(tool.env ?? {}),
+  };
+
+  // execa共通オプション（cwdがundefinedの場合は含めない）
+  const execaOptions = {
+    stdio: "inherit" as const,
+    ...(options.cwd ? { cwd: options.cwd } : {}),
+    env,
+  };
+
+  switch (tool.type) {
+    case "path": {
+      // 絶対パスで直接実行
+      await execa(tool.command, args, execaOptions);
+      break;
+    }
+
+    case "bunx": {
+      // bunx経由でパッケージ実行
+      // bunx [package] [args...]
+      await execa("bunx", [tool.command, ...args], execaOptions);
+      break;
+    }
+
+    case "command": {
+      // PATH解決 → 実行
+      const resolvedPath = await resolveCommand(tool.command);
+      await execa(resolvedPath, args, execaOptions);
+      break;
+    }
+
+    default: {
+      // TypeScriptの型チェックで到達不可能だが、実行時の安全性のため
+      const exhaustiveCheck: never = tool.type;
+      throw new Error(
+        `Unknown tool execution type: ${exhaustiveCheck as string}`,
+      );
+    }
+  }
+}

package/src/repositories/git.repository.ts

@@ -0,0 +1,129 @@
+import { execa } from "execa";
+import { GitError } from "../git.js";
+
+/**
+ * Git操作のための低レベルRepository
+ * execaの直接呼び出しをカプセル化
+ */
+export class GitRepository {
+  async execute(args: string[], options?: { cwd?: string }): Promise<string> {
+    try {
+      const { stdout } = await execa("git", args, options);
+      return stdout;
+    } catch (error) {
+      throw new GitError(`Git command failed: git ${args.join(" ")}`, error);
+    }
+  }
+
+  async isRepository(): Promise<boolean> {
+    try {
+      await this.execute(["rev-parse", "--git-dir"]);
+      return true;
+    } catch {
+      return false;
+    }
+  }
+
+  async getRepositoryRoot(): Promise<string> {
+    const stdout = await this.execute(["rev-parse", "--show-toplevel"]);
+    return stdout.trim();
+  }
+
+  async getCurrentBranch(): Promise<string | null> {
+    try {
+      const stdout = await this.execute(["branch", "--show-current"]);
+      return stdout.trim() || null;
+    } catch {
+      return null;
+    }
+  }
+
+  async getBranches(options: { remote?: boolean }): Promise<string[]> {
+    const args = ["branch"];
+    if (options.remote) {
+      args.push("-r");
+    }
+    args.push("--format=%(refname:short)");
+
+    const stdout = await this.execute(args);
+    return stdout
+      .split("\n")
+      .filter((line) => line.trim())
+      .filter((line) => !line.includes("HEAD"));
+  }
+
+  async createBranch(branchName: string, baseBranch?: string): Promise<void> {
+    const args = ["checkout", "-b", branchName];
+    if (baseBranch) {
+      args.push(baseBranch);
+    }
+    await this.execute(args);
+  }
+
+  async deleteBranch(branchName: string, force = false): Promise<void> {
+    const args = ["branch", force ? "-D" : "-d", branchName];
+    await this.execute(args);
+  }
+
+  async deleteRemoteBranch(branchName: string): Promise<void> {
+    await this.execute(["push", "origin", "--delete", branchName]);
+  }
+
+  async getStatus(options?: { cwd?: string }): Promise<string> {
+    return await this.execute(
+      ["status", "--porcelain"],
+      options?.cwd ? options : undefined,
+    );
+  }
+
+  async hasChanges(workdir?: string): Promise<boolean> {
+    const status = await this.getStatus(workdir ? { cwd: workdir } : undefined);
+    return status.trim().length > 0;
+  }
+
+  async fetch(options?: { all?: boolean; prune?: boolean }): Promise<void> {
+    const args = ["fetch"];
+    if (options?.all) args.push("--all");
+    if (options?.prune) args.push("--prune");
+    await this.execute(args);
+  }
+
+  async push(options?: { upstream?: boolean; branch?: string }): Promise<void> {
+    const args = ["push"];
+    if (options?.upstream && options?.branch) {
+      args.push("--set-upstream", "origin", options.branch);
+    }
+    await this.execute(args);
+  }
+
+  async commit(message: string, options?: { all?: boolean }): Promise<void> {
+    const args = ["commit", "-m", message];
+    if (options?.all) args.push("-a");
+    await this.execute(args);
+  }
+
+  async add(files: string[] | "."): Promise<void> {
+    const args = ["add"];
+    if (Array.isArray(files)) {
+      args.push(...files);
+    } else {
+      args.push(files);
+    }
+    await this.execute(args);
+  }
+
+  async stash(message?: string): Promise<void> {
+    const args = ["stash", "push"];
+    if (message) args.push("-m", message);
+    await this.execute(args);
+  }
+
+  async checkout(target: string): Promise<void> {
+    await this.execute(["checkout", target]);
+  }
+
+  async getChangedFilesCount(workdir?: string): Promise<number> {
+    const status = await this.getStatus(workdir ? { cwd: workdir } : undefined);
+    return status.split("\n").filter((line) => line.trim()).length;
+  }
+}

package/src/repositories/github.repository.ts

@@ -0,0 +1,83 @@
+import { execa } from "execa";
+import chalk from "chalk";
+import type { GitHubPRResponse } from "../cli/ui/types.js";
+
+/**
+ * GitHub CLI操作のための低レベルRepository
+ */
+export class GitHubRepository {
+  async execute(args: string[]): Promise<string> {
+    try {
+      const { stdout } = await execa("gh", args);
+      return stdout;
+    } catch (error) {
+      const message = error instanceof Error ? error.message : String(error);
+      throw new Error(
+        `GitHub CLI command failed: gh ${args.join(" ")}\n${message}`,
+      );
+    }
+  }
+
+  async isAvailable(): Promise<boolean> {
+    try {
+      await this.execute(["--version"]);
+      return true;
+    } catch {
+      return false;
+    }
+  }
+
+  async isAuthenticated(): Promise<boolean> {
+    try {
+      await this.execute(["api", "user"]);
+      return true;
+    } catch {
+      return false;
+    }
+  }
+
+  async fetchPullRequests(options: {
+    state?: "all" | "open" | "closed" | "merged";
+    limit?: number;
+    head?: string;
+  }): Promise<GitHubPRResponse[]> {
+    const args = ["pr", "list"];
+
+    if (options.state) {
+      args.push("--state", options.state);
+    }
+
+    if (options.head) {
+      args.push("--head", options.head);
+    }
+
+    args.push(
+      "--json",
+      "number,title,state,headRefName,mergedAt,author",
+      "--limit",
+      String(options.limit || 100),
+    );
+
+    const stdout = await this.execute(args);
+
+    if (!stdout || stdout.trim() === "") {
+      return [];
+    }
+
+    return JSON.parse(stdout);
+  }
+
+  async fetchRemoteUpdates(): Promise<void> {
+    try {
+      await execa("git", ["fetch", "--all", "--prune"]);
+    } catch {
+      if (process.env.DEBUG_CLEANUP) {
+        console.log(
+          chalk.yellow(
+            "Debug: Failed to fetch remote updates, continuing anyway",
+          ),
+        );
+      }
+    }
+  }
+}

package/src/repositories/worktree.repository.ts

@@ -0,0 +1,69 @@
+import { execa } from "execa";
+import { WorktreeError } from "../worktree.js";
+
+export interface WorktreeData {
+  path: string;
+  head: string;
+  branch: string;
+}
+
+/**
+ * Git Worktree操作のための低レベルRepository
+ */
+export class WorktreeRepository {
+  async execute(args: string[], options?: { cwd?: string }): Promise<string> {
+    try {
+      const { stdout } = await execa("git", ["worktree", ...args], options);
+      return stdout;
+    } catch (error) {
+      throw new WorktreeError(
+        `Worktree command failed: git worktree ${args.join(" ")}`,
+        error,
+      );
+    }
+  }
+
+  async list(): Promise<WorktreeData[]> {
+    const stdout = await this.execute(["list", "--porcelain"]);
+    const worktrees: WorktreeData[] = [];
+    const lines = stdout.split("\n");
+
+    let currentWorktree: Partial<WorktreeData> = {};
+
+    for (const line of lines) {
+      if (line.startsWith("worktree ")) {
+        currentWorktree.path = line.substring(9);
+      } else if (line.startsWith("HEAD ")) {
+        currentWorktree.head = line.substring(5);
+      } else if (line.startsWith("branch ")) {
+        currentWorktree.branch = line.substring(7).replace("refs/heads/", "");
+      } else if (line === "") {
+        if (currentWorktree.path) {
+          worktrees.push(currentWorktree as WorktreeData);
+          currentWorktree = {};
+        }
+      }
+    }
+
+    if (currentWorktree.path) {
+      worktrees.push(currentWorktree as WorktreeData);
+    }
+
+    return worktrees;
+  }
+
+  async add(worktreePath: string, branchName: string): Promise<void> {
+    await this.execute(["add", worktreePath, branchName]);
+  }
+
+  async remove(worktreePath: string, force = false): Promise<void> {
+    const args = ["remove"];
+    if (force) args.push("--force");
+    args.push(worktreePath);
+    await this.execute(args);
+  }
+
+  async prune(): Promise<void> {
+    await this.execute(["prune"]);
+  }
+}

package/src/services/BatchMergeService.ts

@@ -0,0 +1,251 @@
+import type {
+  BatchMergeConfig,
+  BatchMergeProgress,
+  BatchMergeResult,
+  BranchMergeStatus,
+  BatchMergeSummary,
+} from "../cli/ui/types";
+import * as git from "../git";
+import * as worktree from "../worktree";
+
+/**
+ * BatchMergeService - Orchestrates batch merge operations
+ * @see specs/SPEC-ee33ca26/plan.md - Service layer architecture
+ */
+export class BatchMergeService {
+  /**
+   * Determine source branch for merge (main > develop > master)
+   * @returns Source branch name
+   * @throws Error if no source branch found
+   * @see specs/SPEC-ee33ca26/spec.md - FR-004
+   */
+  async determineSourceBranch(): Promise<string> {
+    const branches = await git.getLocalBranches();
+    const branchNames = branches.map((b) => b.name);
+
+    // Priority: main > develop > master
+    if (branchNames.includes("main")) {
+      return "main";
+    }
+    if (branchNames.includes("develop")) {
+      return "develop";
+    }
+    if (branchNames.includes("master")) {
+      return "master";
+    }
+
+    throw new Error("Unable to determine source branch");
+  }
+
+  /**
+   * Get target branches for merge (exclude main, develop, master)
+   * @returns Array of target branch names
+   * @see specs/SPEC-ee33ca26/spec.md - FR-003
+   */
+  async getTargetBranches(): Promise<string[]> {
+    const branches = await git.getLocalBranches();
+    const excludedBranches = ["main", "develop", "master"];
+
+    return branches
+      .map((b) => b.name)
+      .filter((name) => !excludedBranches.includes(name));
+  }
+
+  /**
+   * Ensure worktree exists for target branch
+   * @param branchName - Target branch name
+   * @returns Worktree path
+   * @see specs/SPEC-ee33ca26/spec.md - FR-006
+   */
+  async ensureWorktree(branchName: string): Promise<string> {
+    const worktrees = await worktree.listAdditionalWorktrees();
+    const existingWorktree = worktrees.find((w: { path: string }) =>
+      w.path.includes(branchName.replace(/\//g, "-")),
+    );
+
+    if (existingWorktree) {
+      return existingWorktree.path;
+    }
+
+    // Create new worktree
+    const repoRoot = await git.getRepositoryRoot();
+    const worktreePath = await worktree.generateWorktreePath(
+      repoRoot,
+      branchName,
+    );
+    await worktree.createWorktree({
+      branchName,
+      worktreePath,
+      repoRoot,
+      isNewBranch: false,
+      baseBranch: "",
+    });
+    return worktreePath;
+  }
+
+  /**
+   * Merge source branch into target branch
+   * @param branchName - Target branch name
+   * @param sourceBranch - Source branch name
+   * @param config - Batch merge configuration
+   * @returns Merge status for the branch
+   * @see specs/SPEC-ee33ca26/spec.md - FR-007, FR-008
+   */
+  async mergeBranch(
+    branchName: string,
+    sourceBranch: string,
+    config: BatchMergeConfig,
+  ): Promise<BranchMergeStatus> {
+    const startTime = Date.now();
+    let worktreeCreated = false;
+
+    try {
+      // Ensure worktree exists
+      const worktrees = await worktree.listAdditionalWorktrees();
+      const worktreePath = await this.ensureWorktree(branchName);
+      worktreeCreated = !worktrees.some(
+        (w: { path: string }) => w.path === worktreePath,
+      );
+
+      // Execute merge
+      await git.mergeFromBranch(worktreePath, sourceBranch, config.dryRun);
+
+      // Check for conflicts
+      const hasConflict = await git.hasMergeConflict(worktreePath);
+
+      if (hasConflict) {
+        await git.abortMerge(worktreePath);
+        return {
+          branchName,
+          status: "skipped",
+          worktreeCreated,
+          durationSeconds: (Date.now() - startTime) / 1000,
+        };
+      }
+
+      // Rollback dry-run merge
+      if (config.dryRun) {
+        await git.resetToHead(worktreePath);
+      }
+
+      // Auto-push after successful merge
+      let pushStatus: "success" | "failed" | "not_executed" = "not_executed";
+      if (config.autoPush && !config.dryRun) {
+        try {
+          const currentBranch = await git.getCurrentBranchName(worktreePath);
+          await git.pushBranchToRemote(
+            worktreePath,
+            currentBranch,
+            config.remote || "origin",
+          );
+          pushStatus = "success";
+        } catch {
+          // Push failure should not fail the merge
+          pushStatus = "failed";
+        }
+      }
+
+      return {
+        branchName,
+        status: "success",
+        pushStatus,
+        worktreeCreated,
+        durationSeconds: (Date.now() - startTime) / 1000,
+      };
+    } catch (error) {
+      // Check if it's a merge conflict
+      const hasConflict = await git.hasMergeConflict(
+        await this.ensureWorktree(branchName),
+      );
+
+      if (hasConflict) {
+        try {
+          await git.abortMerge(await this.ensureWorktree(branchName));
+        } catch {
+          // Ignore abort errors
+        }
+
+        return {
+          branchName,
+          status: "skipped",
+          worktreeCreated,
+          durationSeconds: (Date.now() - startTime) / 1000,
+        };
+      }
+
+      return {
+        branchName,
+        status: "failed",
+        error: error instanceof Error ? error.message : String(error),
+        worktreeCreated,
+        durationSeconds: (Date.now() - startTime) / 1000,
+      };
+    }
+  }
+
+  /**
+   * Execute batch merge for all target branches
+   * @param config - Batch merge configuration
+   * @param onProgress - Progress callback function
+   * @returns Batch merge result
+   * @see specs/SPEC-ee33ca26/spec.md - FR-001 to FR-015
+   */
+  async executeBatchMerge(
+    config: BatchMergeConfig,
+    onProgress?: (progress: BatchMergeProgress) => void,
+  ): Promise<BatchMergeResult> {
+    const startTime = Date.now();
+    const statuses: BranchMergeStatus[] = [];
+
+    // Fetch latest from remote
+    await git.fetchAllRemotes();
+
+    const totalBranches = config.targetBranches.length;
+
+    for (let i = 0; i < totalBranches; i++) {
+      const branchName = config.targetBranches[i] || "";
+      const elapsedSeconds = (Date.now() - startTime) / 1000;
+
+      // Report progress
+      if (onProgress) {
+        const progress: BatchMergeProgress = {
+          currentBranch: branchName,
+          currentIndex: i,
+          totalBranches,
+          percentage: Math.floor((i / totalBranches) * 100),
+          elapsedSeconds,
+          currentPhase: "merge",
+        };
+        onProgress(progress);
+      }
+
+      // Merge branch
+      if (branchName) {
+        const status = await this.mergeBranch(
+          branchName,
+          config.sourceBranch,
+          config,
+        );
+        statuses.push(status);
+      }
+    }
+
+    // Calculate summary
+    const summary: BatchMergeSummary = {
+      totalCount: statuses.length,
+      successCount: statuses.filter((s) => s.status === "success").length,
+      skippedCount: statuses.filter((s) => s.status === "skipped").length,
+      failedCount: statuses.filter((s) => s.status === "failed").length,
+      pushedCount: 0,
+      pushFailedCount: 0,
+    };
+
+    return {
+      statuses,
+      summary,
+      totalDurationSeconds: (Date.now() - startTime) / 1000,
+      cancelled: false,
+      config,
+    };
+  }
+}