@akiojin/gwt 2.1.1 → 2.3.0

package/src/cli/ui/types.ts

@@ -8,7 +8,14 @@ export interface WorktreeInfo {
 export interface BranchInfo {
   name: string;
   type: "local" | "remote";
-  branchType: "feature" | "bugfix" | "hotfix" | "release" | "main" | "develop" | "other";
+  branchType:
+    | "feature"
+    | "bugfix"
+    | "hotfix"
+    | "release"
+    | "main"
+    | "develop"
+    | "other";
   isCurrent: boolean;
   description?: string;
   worktree?: WorktreeInfo;

package/src/config/builtin-tools.ts

@@ -1,7 +1,7 @@
 /**
  * ビルトインAIツール定義
  *
- * Claude Code と Codex CLI の CustomAITool 形式定義
+ * Claude Code、Codex、Gemini、Qwen の CustomAITool 形式定義
  */
 
 import type { CustomAITool } from "../types/tools.js";
@@ -23,11 +23,11 @@ export const CLAUDE_CODE_TOOL: CustomAITool = {
 };
 
 /**
- * Codex CLI のビルトイン定義
+ * Codex のビルトイン定義
  */
 export const CODEX_CLI_TOOL: CustomAITool = {
   id: "codex-cli",
-  displayName: "Codex CLI",
+  displayName: "Codex",
   type: "bunx",
   command: "@openai/codex@latest",
   defaultArgs: ["--auto-approve", "--verbose"],
@@ -38,7 +38,45 @@ export const CODEX_CLI_TOOL: CustomAITool = {
   },
 };
 
+/**
+ * Gemini のビルトイン定義
+ */
+export const GEMINI_CLI_TOOL: CustomAITool = {
+  id: "gemini-cli",
+  displayName: "Gemini",
+  type: "bunx",
+  command: "@google/gemini-cli@latest",
+  modeArgs: {
+    normal: [],
+    continue: ["-r", "latest"],
+    resume: ["-r", "latest"],
+  },
+  permissionSkipArgs: ["-y"],
+};
+
+/**
+ * Qwen のビルトイン定義
+ */
+export const QWEN_CLI_TOOL: CustomAITool = {
+  id: "qwen-cli",
+  displayName: "Qwen",
+  type: "bunx",
+  command: "@qwen-code/qwen-code@latest",
+  defaultArgs: ["--checkpointing"],
+  modeArgs: {
+    normal: [],
+    continue: [],
+    resume: [],
+  },
+  permissionSkipArgs: ["--yolo"],
+};
+
 /**
  * すべてのビルトインツール
  */
-export const BUILTIN_TOOLS: CustomAITool[] = [CLAUDE_CODE_TOOL, CODEX_CLI_TOOL];
+export const BUILTIN_TOOLS: CustomAITool[] = [
+  CLAUDE_CODE_TOOL,
+  CODEX_CLI_TOOL,
+  GEMINI_CLI_TOOL,
+  QWEN_CLI_TOOL,
+];

package/src/config/index.ts

@@ -88,12 +88,7 @@ export function resetConfigCache(): void {
  * セッションデータの保存・読み込み
  */
 function getSessionFilePath(repositoryRoot: string): string {
-  const sessionDir = path.join(
-    homedir(),
-    ".config",
-    "gwt",
-    "sessions",
-  );
+  const sessionDir = path.join(homedir(), ".config", "gwt", "sessions");
   const repoName = path.basename(repositoryRoot);
   const repoHash = Buffer.from(repositoryRoot)
     .toString("base64")
@@ -152,12 +147,7 @@ export async function loadSession(
 
 export async function getAllSessions(): Promise<SessionData[]> {
   try {
-    const sessionDir = path.join(
-      homedir(),
-      ".config",
-      "gwt",
-      "sessions",
-    );
+    const sessionDir = path.join(homedir(), ".config", "gwt", "sessions");
     const { readdir } = await import("node:fs/promises");
 
     const files = await readdir(sessionDir);

package/src/config/tools.ts

@@ -7,7 +7,14 @@
 
 import { homedir } from "node:os";
 import path from "node:path";
-import { readFile, writeFile, mkdir, rename, access, cp } from "node:fs/promises";
+import {
+  readFile,
+  writeFile,
+  mkdir,
+  rename,
+  access,
+  cp,
+} from "node:fs/promises";
 import type {
   ToolsConfig,
   CustomAITool,
@@ -20,11 +27,12 @@ import { BUILTIN_TOOLS } from "./builtin-tools.js";
  * 環境変数の優先順位: GWT_HOME > CLAUDE_WORKTREE_HOME (後方互換性) > ホームディレクトリ
  */
 export const WORKTREE_HOME =
-  (process.env.GWT_HOME && process.env.GWT_HOME.trim().length > 0)
+  process.env.GWT_HOME && process.env.GWT_HOME.trim().length > 0
     ? process.env.GWT_HOME
-    : (process.env.CLAUDE_WORKTREE_HOME && process.env.CLAUDE_WORKTREE_HOME.trim().length > 0)
-    ? process.env.CLAUDE_WORKTREE_HOME
-    : homedir();
+    : process.env.CLAUDE_WORKTREE_HOME &&
+        process.env.CLAUDE_WORKTREE_HOME.trim().length > 0
+      ? process.env.CLAUDE_WORKTREE_HOME
+      : homedir();
 
 const LEGACY_CONFIG_DIR = path.join(homedir(), ".claude-worktree");
 export const CONFIG_DIR = path.join(WORKTREE_HOME, ".gwt");
@@ -55,7 +63,9 @@ async function migrateLegacyConfig(): Promise<void> {
     // レガシーディレクトリを新しいディレクトリにコピー
     await mkdir(path.dirname(CONFIG_DIR), { recursive: true });
     await cp(LEGACY_CONFIG_DIR, CONFIG_DIR, { recursive: true });
-    console.log(`✅ Migrated configuration from ${LEGACY_CONFIG_DIR} to ${CONFIG_DIR}`);
+    console.log(
+      `✅ Migrated configuration from ${LEGACY_CONFIG_DIR} to ${CONFIG_DIR}`,
+    );
   } catch (error) {
     // 移行に失敗しても継続(エラーログのみ)
     if (process.env.DEBUG) {

package/src/gemini.ts

@@ -0,0 +1,202 @@
+import { execa } from "execa";
+import chalk from "chalk";
+import { platform } from "os";
+import { existsSync } from "fs";
+import { createChildStdio, getTerminalStreams } from "./utils/terminal.js";
+
+const GEMINI_CLI_PACKAGE = "@google/gemini-cli@latest";
+
+export class GeminiError extends Error {
+  constructor(
+    message: string,
+    public cause?: unknown,
+  ) {
+    super(message);
+    this.name = "GeminiError";
+  }
+}
+
+export async function launchGeminiCLI(
+  worktreePath: string,
+  options: {
+    skipPermissions?: boolean;
+    mode?: "normal" | "continue" | "resume";
+    extraArgs?: string[];
+    envOverrides?: Record<string, string>;
+  } = {},
+): Promise<void> {
+  const terminal = getTerminalStreams();
+
+  try {
+    // Check if the worktree path exists
+    if (!existsSync(worktreePath)) {
+      throw new Error(`Worktree path does not exist: ${worktreePath}`);
+    }
+
+    console.log(chalk.blue("🚀 Launching Gemini CLI..."));
+    console.log(chalk.gray(`   Working directory: ${worktreePath}`));
+
+    const args: string[] = [];
+
+    // Handle execution mode
+    switch (options.mode) {
+      case "continue":
+        args.push("-r", "latest");
+        console.log(chalk.cyan("   ⏭️  Continuing most recent session"));
+        break;
+      case "resume":
+        args.push("-r", "latest");
+        console.log(chalk.cyan("   🔄 Resuming session"));
+        break;
+      case "normal":
+      default:
+        console.log(chalk.green("   ✨ Starting new session"));
+        break;
+    }
+
+    // Handle skip permissions (YOLO mode)
+    if (options.skipPermissions) {
+      args.push("-y");
+      console.log(
+        chalk.yellow("   ⚠️  Auto-approving all actions (YOLO mode)"),
+      );
+    }
+
+    // Append any pass-through arguments after our flags
+    if (options.extraArgs && options.extraArgs.length > 0) {
+      args.push(...options.extraArgs);
+    }
+
+    terminal.exitRawMode();
+
+    const baseEnv = {
+      ...process.env,
+      ...(options.envOverrides ?? {}),
+    };
+
+    const childStdio = createChildStdio();
+
+    // Auto-detect locally installed gemini command
+    const hasLocalGemini = await isGeminiCommandAvailable();
+
+    try {
+      if (hasLocalGemini) {
+        // Use locally installed gemini command
+        console.log(
+          chalk.green("   ✨ Using locally installed gemini command"),
+        );
+        await execa("gemini", args, {
+          cwd: worktreePath,
+          shell: true,
+          stdin: childStdio.stdin,
+          stdout: childStdio.stdout,
+          stderr: childStdio.stderr,
+          env: baseEnv,
+        } as any);
+      } else {
+        // Fallback to bunx
+        console.log(
+          chalk.cyan("   🔄 Falling back to bunx @google/gemini-cli@latest"),
+        );
+        console.log(
+          chalk.yellow(
+            "   💡 Recommended: Install Gemini CLI globally for faster startup",
+          ),
+        );
+        console.log(chalk.yellow("      npm install -g @google/gemini-cli"));
+        console.log("");
+        // Wait 2 seconds to let user read the message
+        await new Promise((resolve) => setTimeout(resolve, 2000));
+        await execa("bunx", [GEMINI_CLI_PACKAGE, ...args], {
+          cwd: worktreePath,
+          shell: true,
+          stdin: childStdio.stdin,
+          stdout: childStdio.stdout,
+          stderr: childStdio.stderr,
+          env: baseEnv,
+        } as any);
+      }
+    } finally {
+      childStdio.cleanup();
+    }
+  } catch (error: any) {
+    const hasLocalGemini = await isGeminiCommandAvailable();
+    let errorMessage: string;
+
+    if (error.code === "ENOENT") {
+      if (hasLocalGemini) {
+        errorMessage =
+          "gemini command not found. Please ensure Gemini CLI is properly installed.";
+      } else {
+        errorMessage =
+          "bunx command not found. Please ensure Bun is installed so Gemini CLI can run via bunx.";
+      }
+    } else {
+      errorMessage = `Failed to launch Gemini CLI: ${error.message || "Unknown error"}`;
+    }
+
+    if (platform() === "win32") {
+      console.error(chalk.red("\n💡 Windows troubleshooting tips:"));
+      if (hasLocalGemini) {
+        console.error(
+          chalk.yellow(
+            "   1. Confirm that Gemini CLI is installed and the 'gemini' command is on PATH",
+          ),
+        );
+        console.error(
+          chalk.yellow('   2. Run "gemini --version" to verify the setup'),
+        );
+      } else {
+        console.error(
+          chalk.yellow(
+            "   1. Confirm that Bun is installed and bunx is available",
+          ),
+        );
+        console.error(
+          chalk.yellow(
+            '   2. Run "bunx @google/gemini-cli@latest -- --version" to verify the setup',
+          ),
+        );
+      }
+      console.error(
+        chalk.yellow("   3. Restart your terminal or IDE to refresh PATH"),
+      );
+    }
+
+    throw new GeminiError(errorMessage, error);
+  } finally {
+    terminal.exitRawMode();
+  }
+}
+
+/**
+ * Check if locally installed `gemini` command is available
+ * @returns true if `gemini` command exists in PATH, false otherwise
+ */
+async function isGeminiCommandAvailable(): Promise<boolean> {
+  try {
+    const command = platform() === "win32" ? "where" : "which";
+    await execa(command, ["gemini"], { shell: true });
+    return true;
+  } catch {
+    // gemini command not found in PATH
+    return false;
+  }
+}
+
+export async function isGeminiCLIAvailable(): Promise<boolean> {
+  try {
+    await execa("bunx", [GEMINI_CLI_PACKAGE, "--version"], { shell: true });
+    return true;
+  } catch (error: any) {
+    if (error.code === "ENOENT") {
+      console.error(chalk.yellow("\n⚠️  bunx command not found"));
+      console.error(
+        chalk.gray(
+          "   Install Bun and confirm that bunx is available before continuing",
+        ),
+      );
+    }
+    return false;
+  }
+}

package/src/git.ts

@@ -351,7 +351,8 @@ function getBranchType(branchName: string): BranchInfo["branchType"] {
   if (branchName === "main" || branchName === "master") return "main";
   if (branchName === "develop" || branchName === "dev") return "develop";
   if (branchName.startsWith("feature/")) return "feature";
-  if (branchName.startsWith("bugfix/") || branchName.startsWith("bug/")) return "bugfix";
+  if (branchName.startsWith("bugfix/") || branchName.startsWith("bug/"))
+    return "bugfix";
   if (branchName.startsWith("hotfix/")) return "hotfix";
   if (branchName.startsWith("release/")) return "release";
   return "other";

package/src/index.ts

@@ -11,6 +11,8 @@ import {
 } from "./git.js";
 import { launchClaudeCode } from "./claude.js";
 import { launchCodexCLI, CodexError } from "./codex.js";
+import { launchGeminiCLI, GeminiError } from "./gemini.js";
+import { launchQwenCLI, QwenError } from "./qwen.js";
 import {
   WorktreeOrchestrator,
   type EnsureWorktreeOptions,
@@ -96,6 +98,8 @@ function isRecoverableError(error: unknown): boolean {
     error instanceof GitError ||
     error instanceof WorktreeError ||
     error instanceof CodexError ||
+    error instanceof GeminiError ||
+    error instanceof QwenError ||
     error instanceof DependencyInstallError
   ) {
     return true;
@@ -106,6 +110,8 @@ function isRecoverableError(error: unknown): boolean {
       error.name === "GitError" ||
       error.name === "WorktreeError" ||
       error.name === "CodexError" ||
+      error.name === "GeminiError" ||
+      error.name === "QwenError" ||
       error.name === "DependencyInstallError"
     );
   }
@@ -119,6 +125,8 @@ function isRecoverableError(error: unknown): boolean {
       name === "GitError" ||
       name === "WorktreeError" ||
       name === "CodexError" ||
+      name === "GeminiError" ||
+      name === "QwenError" ||
       name === "DependencyInstallError"
     );
   }
@@ -541,6 +549,28 @@ export async function handleAIToolWorkflow(
         bypassApprovals: skipPermissions,
         envOverrides: sharedEnv,
       });
+    } else if (tool === "gemini-cli") {
+      await launchGeminiCLI(worktreePath, {
+        mode:
+          mode === "resume"
+            ? "resume"
+            : mode === "continue"
+              ? "continue"
+              : "normal",
+        skipPermissions,
+        envOverrides: sharedEnv,
+      });
+    } else if (tool === "qwen-cli") {
+      await launchQwenCLI(worktreePath, {
+        mode:
+          mode === "resume"
+            ? "resume"
+            : mode === "continue"
+              ? "continue"
+              : "normal",
+        skipPermissions,
+        envOverrides: sharedEnv,
+      });
     } else {
       // Custom tool
       printInfo(`Launching custom tool: ${toolConfig.displayName}`);

package/src/qwen.ts

@@ -0,0 +1,208 @@
+import { execa } from "execa";
+import chalk from "chalk";
+import { platform } from "os";
+import { existsSync } from "fs";
+import { createChildStdio, getTerminalStreams } from "./utils/terminal.js";
+
+const QWEN_CLI_PACKAGE = "@qwen-code/qwen-code@latest";
+
+export class QwenError extends Error {
+  constructor(
+    message: string,
+    public cause?: unknown,
+  ) {
+    super(message);
+    this.name = "QwenError";
+  }
+}
+
+export async function launchQwenCLI(
+  worktreePath: string,
+  options: {
+    skipPermissions?: boolean;
+    mode?: "normal" | "continue" | "resume";
+    extraArgs?: string[];
+    envOverrides?: Record<string, string>;
+  } = {},
+): Promise<void> {
+  const terminal = getTerminalStreams();
+
+  try {
+    // Check if the worktree path exists
+    if (!existsSync(worktreePath)) {
+      throw new Error(`Worktree path does not exist: ${worktreePath}`);
+    }
+
+    console.log(chalk.blue("🚀 Launching Qwen CLI..."));
+    console.log(chalk.gray(`   Working directory: ${worktreePath}`));
+
+    const args: string[] = ["--checkpointing"];
+
+    // Handle execution mode
+    // Note: Qwen CLI doesn't have explicit continue/resume CLI options at startup.
+    // Session management is done via /chat commands during interactive sessions.
+    switch (options.mode) {
+      case "continue":
+        console.log(
+          chalk.cyan(
+            "   ⏭️  Starting session (use /chat resume in the CLI to continue)",
+          ),
+        );
+        break;
+      case "resume":
+        console.log(
+          chalk.cyan(
+            "   🔄 Starting session (use /chat resume in the CLI to continue)",
+          ),
+        );
+        break;
+      case "normal":
+      default:
+        console.log(chalk.green("   ✨ Starting new session"));
+        break;
+    }
+
+    // Handle skip permissions (YOLO mode)
+    if (options.skipPermissions) {
+      args.push("--yolo");
+      console.log(
+        chalk.yellow("   ⚠️  Auto-approving all actions (YOLO mode)"),
+      );
+    }
+
+    // Append any pass-through arguments after our flags
+    if (options.extraArgs && options.extraArgs.length > 0) {
+      args.push(...options.extraArgs);
+    }
+
+    terminal.exitRawMode();
+
+    const baseEnv = {
+      ...process.env,
+      ...(options.envOverrides ?? {}),
+    };
+
+    const childStdio = createChildStdio();
+
+    // Auto-detect locally installed qwen command
+    const hasLocalQwen = await isQwenCommandAvailable();
+
+    try {
+      if (hasLocalQwen) {
+        // Use locally installed qwen command
+        console.log(chalk.green("   ✨ Using locally installed qwen command"));
+        await execa("qwen", args, {
+          cwd: worktreePath,
+          shell: true,
+          stdin: childStdio.stdin,
+          stdout: childStdio.stdout,
+          stderr: childStdio.stderr,
+          env: baseEnv,
+        } as any);
+      } else {
+        // Fallback to bunx
+        console.log(
+          chalk.cyan("   🔄 Falling back to bunx @qwen-code/qwen-code@latest"),
+        );
+        console.log(
+          chalk.yellow(
+            "   💡 Recommended: Install Qwen CLI globally for faster startup",
+          ),
+        );
+        console.log(chalk.yellow("      npm install -g @qwen-code/qwen-code"));
+        console.log("");
+        // Wait 2 seconds to let user read the message
+        await new Promise((resolve) => setTimeout(resolve, 2000));
+        await execa("bunx", [QWEN_CLI_PACKAGE, ...args], {
+          cwd: worktreePath,
+          shell: true,
+          stdin: childStdio.stdin,
+          stdout: childStdio.stdout,
+          stderr: childStdio.stderr,
+          env: baseEnv,
+        } as any);
+      }
+    } finally {
+      childStdio.cleanup();
+    }
+  } catch (error: any) {
+    const hasLocalQwen = await isQwenCommandAvailable();
+    let errorMessage: string;
+
+    if (error.code === "ENOENT") {
+      if (hasLocalQwen) {
+        errorMessage =
+          "qwen command not found. Please ensure Qwen CLI is properly installed.";
+      } else {
+        errorMessage =
+          "bunx command not found. Please ensure Bun is installed so Qwen CLI can run via bunx.";
+      }
+    } else {
+      errorMessage = `Failed to launch Qwen CLI: ${error.message || "Unknown error"}`;
+    }
+
+    if (platform() === "win32") {
+      console.error(chalk.red("\n💡 Windows troubleshooting tips:"));
+      if (hasLocalQwen) {
+        console.error(
+          chalk.yellow(
+            "   1. Confirm that Qwen CLI is installed and the 'qwen' command is on PATH",
+          ),
+        );
+        console.error(
+          chalk.yellow('   2. Run "qwen --version" to verify the setup'),
+        );
+      } else {
+        console.error(
+          chalk.yellow(
+            "   1. Confirm that Bun is installed and bunx is available",
+          ),
+        );
+        console.error(
+          chalk.yellow(
+            '   2. Run "bunx @qwen-code/qwen-code@latest -- --version" to verify the setup',
+          ),
+        );
+      }
+      console.error(
+        chalk.yellow("   3. Restart your terminal or IDE to refresh PATH"),
+      );
+    }
+
+    throw new QwenError(errorMessage, error);
+  } finally {
+    terminal.exitRawMode();
+  }
+}
+
+/**
+ * Check if locally installed `qwen` command is available
+ * @returns true if `qwen` command exists in PATH, false otherwise
+ */
+async function isQwenCommandAvailable(): Promise<boolean> {
+  try {
+    const command = platform() === "win32" ? "where" : "which";
+    await execa(command, ["qwen"], { shell: true });
+    return true;
+  } catch {
+    // qwen command not found in PATH
+    return false;
+  }
+}
+
+export async function isQwenCLIAvailable(): Promise<boolean> {
+  try {
+    await execa("bunx", [QWEN_CLI_PACKAGE, "--version"], { shell: true });
+    return true;
+  } catch (error: any) {
+    if (error.code === "ENOENT") {
+      console.error(chalk.yellow("\n⚠️  bunx command not found"));
+      console.error(
+        chalk.gray(
+          "   Install Bun and confirm that bunx is available before continuing",
+        ),
+      );
+    }
+    return false;
+  }
+}

package/src/services/git.service.ts

@@ -52,7 +52,8 @@ export class GitService {
 
   private getBranchType(branchName: string): BranchInfo["branchType"] {
     if (branchName.startsWith("feature/")) return "feature";
-    if (branchName.startsWith("bugfix/") || branchName.startsWith("bug/")) return "bugfix";
+    if (branchName.startsWith("bugfix/") || branchName.startsWith("bug/"))
+      return "bugfix";
     if (branchName.startsWith("hotfix/")) return "hotfix";
     if (branchName.startsWith("release/")) return "release";
     if (branchName === "main" || branchName === "master") return "main";

package/src/web/client/src/components/BranchGraph.tsx

@@ -61,7 +61,7 @@ export function BranchGraph({ branches }: BranchGraphProps) {
 
       if (!laneMap.has(base)) {
         const baseNode =
-          base !== UNKNOWN_BASE ? branchMap.get(base) ?? null : null;
+          base !== UNKNOWN_BASE ? (branchMap.get(base) ?? null) : null;
         laneMap.set(base, {
           id: base,
           baseLabel: base === UNKNOWN_BASE ? "ベース不明" : base,
@@ -103,7 +103,8 @@ export function BranchGraph({ branches }: BranchGraphProps) {
           <p className="branch-graph-panel__eyebrow">BRANCH GRAPH</p>
           <h2>ベースブランチの関係をグラフィカルに把握</h2>
           <p>
-            baseRef、Git upstream、merge-baseヒューリスティクスを用いて推定したベースブランチ単位で
+            baseRef、Git
+            upstream、merge-baseヒューリスティクスを用いて推定したベースブランチ単位で
             派生ノードをレーン表示します。
           </p>
         </div>