@akiojin/gwt 2.2.0 → 2.4.0

package/src/codex.ts

@@ -5,14 +5,23 @@ import { existsSync } from "fs";
 import { createChildStdio, getTerminalStreams } from "./utils/terminal.js";
 
 const CODEX_CLI_PACKAGE = "@openai/codex@latest";
-const DEFAULT_CODEX_ARGS = [
+
+export type CodexReasoningEffort = "low" | "medium" | "high" | "xhigh";
+
+export const DEFAULT_CODEX_MODEL = "gpt-5.1-codex";
+export const DEFAULT_CODEX_REASONING_EFFORT: CodexReasoningEffort = "high";
+
+export const buildDefaultCodexArgs = (
+  model: string = DEFAULT_CODEX_MODEL,
+  reasoningEffort: CodexReasoningEffort = DEFAULT_CODEX_REASONING_EFFORT,
+): string[] => [
   "--enable",
   "web_search_request",
-  "--model=gpt-5.1-codex",
+  `--model=${model}`,
   "--sandbox",
   "workspace-write",
   "-c",
-  "model_reasoning_effort=high",
+  `model_reasoning_effort=${reasoningEffort}`,
   "-c",
   "model_reasoning_summaries=detailed",
   "-c",
@@ -42,6 +51,8 @@ export async function launchCodexCLI(
     extraArgs?: string[];
     bypassApprovals?: boolean;
     envOverrides?: Record<string, string>;
+    model?: string;
+    reasoningEffort?: CodexReasoningEffort;
   } = {},
 ): Promise<void> {
   const terminal = getTerminalStreams();
@@ -55,6 +66,12 @@ export async function launchCodexCLI(
     console.log(chalk.gray(`   Working directory: ${worktreePath}`));
 
     const args: string[] = [];
+    const model = options.model ?? DEFAULT_CODEX_MODEL;
+    const reasoningEffort =
+      options.reasoningEffort ?? DEFAULT_CODEX_REASONING_EFFORT;
+
+    console.log(chalk.green(`   🎯 Model: ${model}`));
+    console.log(chalk.green(`   🧠 Reasoning: ${reasoningEffort}`));
 
     switch (options.mode) {
       case "continue":
@@ -80,7 +97,9 @@ export async function launchCodexCLI(
       args.push(...options.extraArgs);
     }
 
-    args.push(...DEFAULT_CODEX_ARGS);
+    const codexArgs = buildDefaultCodexArgs(model, reasoningEffort);
+
+    args.push(...codexArgs);
 
     terminal.exitRawMode();
 

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,207 @@
+import { execa } from "execa";
+import chalk from "chalk";
+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>;
+    model?: 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[] = [];
+
+    if (options.model) {
+      args.push("--model", options.model);
+      console.log(chalk.green(`   🎯 Model: ${options.model}`));
+    }
+
+    // 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 (process.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 = process.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

@@ -10,7 +10,13 @@ import {
   GitError,
 } from "./git.js";
 import { launchClaudeCode } from "./claude.js";
-import { launchCodexCLI, CodexError } from "./codex.js";
+import {
+  launchCodexCLI,
+  CodexError,
+  type CodexReasoningEffort,
+} from "./codex.js";
+import { launchGeminiCLI, GeminiError } from "./gemini.js";
+import { launchQwenCLI, QwenError } from "./qwen.js";
 import {
   WorktreeOrchestrator,
   type EnsureWorktreeOptions,
@@ -96,6 +102,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 +114,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 +129,8 @@ function isRecoverableError(error: unknown): boolean {
       name === "GitError" ||
       name === "WorktreeError" ||
       name === "CodexError" ||
+      name === "GeminiError" ||
+      name === "QwenError" ||
       name === "DependencyInstallError"
     );
   }
@@ -284,11 +296,17 @@ export async function handleAIToolWorkflow(
     tool,
     mode,
     skipPermissions,
+    model,
+    inferenceLevel,
   } = selectionResult;
 
   const branchLabel = displayName ?? branch;
+  const modelInfo =
+    model || inferenceLevel
+      ? `, model=${model ?? "default"}${inferenceLevel ? `/${inferenceLevel}` : ""}`
+      : "";
   printInfo(
-    `Selected: ${branchLabel} with ${tool} (${mode} mode, skipPermissions: ${skipPermissions})`,
+    `Selected: ${branchLabel} with ${tool} (${mode} mode${modelInfo}, skipPermissions: ${skipPermissions})`,
   );
 
   try {
@@ -520,7 +538,12 @@ export async function handleAIToolWorkflow(
     // Builtin tools use their dedicated launch functions
     // Custom tools use the generic launchCustomAITool function
     if (tool === "claude-code") {
-      await launchClaudeCode(worktreePath, {
+      const launchOptions: {
+        mode?: "normal" | "continue" | "resume";
+        skipPermissions?: boolean;
+        envOverrides?: Record<string, string>;
+        model?: string;
+      } = {
         mode:
           mode === "resume"
             ? "resume"
@@ -529,9 +552,19 @@ export async function handleAIToolWorkflow(
               : "normal",
         skipPermissions,
         envOverrides: sharedEnv,
-      });
+      };
+      if (model) {
+        launchOptions.model = model;
+      }
+      await launchClaudeCode(worktreePath, launchOptions);
     } else if (tool === "codex-cli") {
-      await launchCodexCLI(worktreePath, {
+      const launchOptions: {
+        mode?: "normal" | "continue" | "resume";
+        bypassApprovals?: boolean;
+        envOverrides?: Record<string, string>;
+        model?: string;
+        reasoningEffort?: CodexReasoningEffort;
+      } = {
         mode:
           mode === "resume"
             ? "resume"
@@ -540,7 +573,54 @@ export async function handleAIToolWorkflow(
               : "normal",
         bypassApprovals: skipPermissions,
         envOverrides: sharedEnv,
-      });
+      };
+      if (model) {
+        launchOptions.model = model;
+      }
+      if (inferenceLevel) {
+        launchOptions.reasoningEffort = inferenceLevel as CodexReasoningEffort;
+      }
+      await launchCodexCLI(worktreePath, launchOptions);
+    } else if (tool === "gemini-cli") {
+      const launchOptions: {
+        mode?: "normal" | "continue" | "resume";
+        skipPermissions?: boolean;
+        envOverrides?: Record<string, string>;
+        model?: string;
+      } = {
+        mode:
+          mode === "resume"
+            ? "resume"
+            : mode === "continue"
+              ? "continue"
+              : "normal",
+        skipPermissions,
+        envOverrides: sharedEnv,
+      };
+      if (model) {
+        launchOptions.model = model;
+      }
+      await launchGeminiCLI(worktreePath, launchOptions);
+    } else if (tool === "qwen-cli") {
+      const launchOptions: {
+        mode?: "normal" | "continue" | "resume";
+        skipPermissions?: boolean;
+        envOverrides?: Record<string, string>;
+        model?: string;
+      } = {
+        mode:
+          mode === "resume"
+            ? "resume"
+            : mode === "continue"
+              ? "continue"
+              : "normal",
+        skipPermissions,
+        envOverrides: sharedEnv,
+      };
+      if (model) {
+        launchOptions.model = model;
+      }
+      await launchQwenCLI(worktreePath, launchOptions);
     } else {
       // Custom tool
       printInfo(`Launching custom tool: ${toolConfig.displayName}`);