@akiojin/gwt 2.3.0 → 2.4.1

package/src/cli/ui/utils/modelOptions.ts

@@ -0,0 +1,125 @@
+import type { AITool, InferenceLevel, ModelOption } from "../types.js";
+
+const CODEX_BASE_LEVELS: InferenceLevel[] = ["high", "medium", "low"];
+const CODEX_MAX_LEVELS: InferenceLevel[] = ["xhigh", "high", "medium", "low"];
+
+const MODEL_OPTIONS: Record<string, ModelOption[]> = {
+  "claude-code": [
+    {
+      id: "default",
+      label: "Default (recommended) — Sonnet 4.5",
+      description:
+        "Official default alias. Tracks the recommended Claude Code model (currently Sonnet 4.5) and shows as a standard model in /model.",
+      isDefault: true,
+    },
+    {
+      id: "opus",
+      label: "Opus 4.1",
+      description:
+        "Official Opus alias for Claude Code (non-custom, matches /model option).",
+    },
+    {
+      id: "haiku",
+      label: "Haiku 4.5",
+      description:
+        "Official Haiku alias for Claude Code (fastest model, non-custom).",
+    },
+  ],
+  "codex-cli": [
+    {
+      id: "gpt-5.1-codex",
+      label: "gpt-5.1-codex",
+      description: "Standard Codex model",
+      inferenceLevels: CODEX_BASE_LEVELS,
+      defaultInference: "high",
+      isDefault: true,
+    },
+    {
+      id: "gpt-5.1-codex-max",
+      label: "gpt-5.1-codex-max",
+      description: "Max performance (xhigh available)",
+      inferenceLevels: CODEX_MAX_LEVELS,
+      defaultInference: "medium",
+    },
+    {
+      id: "gpt-5.1-codex-mini",
+      label: "gpt-5.1-codex-mini",
+      description: "Lightweight / cost-saving",
+      inferenceLevels: CODEX_BASE_LEVELS,
+      defaultInference: "medium",
+    },
+    {
+      id: "gpt-5.1",
+      label: "gpt-5.1",
+      description: "General-purpose GPT-5.1",
+      inferenceLevels: CODEX_BASE_LEVELS,
+      defaultInference: "high",
+    },
+  ],
+  "gemini-cli": [
+    {
+      id: "gemini-3-pro-preview",
+      label: "Pro (gemini-3-pro-preview)",
+      description:
+        "Default Pro. Falls back to gemini-2.5-pro when preview is unavailable.",
+      isDefault: true,
+    },
+    {
+      id: "gemini-2.5-pro",
+      label: "Pro (gemini-2.5-pro)",
+      description: "Stable Pro model for deep reasoning and creativity",
+    },
+    {
+      id: "gemini-2.5-flash",
+      label: "Flash (gemini-2.5-flash)",
+      description: "Balance of speed and reasoning",
+    },
+    {
+      id: "gemini-2.5-flash-lite",
+      label: "Flash-Lite (gemini-2.5-flash-lite)",
+      description: "Fastest for simple tasks",
+    },
+  ],
+  "qwen-cli": [
+    {
+      id: "coder-model",
+      label: "Coder Model",
+      description:
+        "Latest Qwen Coder model (qwen3-coder-plus-2025-09-23) from Alibaba Cloud ModelStudio",
+      isDefault: true,
+    },
+    {
+      id: "vision-model",
+      label: "Vision Model",
+      description:
+        "Latest Qwen Vision model (qwen3-vl-plus-2025-09-23) from Alibaba Cloud ModelStudio",
+    },
+  ],
+};
+
+export function getModelOptions(tool: AITool): ModelOption[] {
+  return MODEL_OPTIONS[tool] ?? [];
+}
+
+export function getDefaultModelOption(tool: AITool): ModelOption | undefined {
+  const options = getModelOptions(tool);
+  return options.find((opt) => opt.isDefault) ?? options[0];
+}
+
+export function getInferenceLevelsForModel(
+  model?: ModelOption,
+): InferenceLevel[] {
+  if (!model?.inferenceLevels || model.inferenceLevels.length === 0) {
+    return [];
+  }
+  return model.inferenceLevels;
+}
+
+export function getDefaultInferenceForModel(
+  model?: ModelOption,
+): InferenceLevel | undefined {
+  if (!model) return undefined;
+  if (model.defaultInference) return model.defaultInference;
+  const levels = getInferenceLevelsForModel(model);
+  return levels[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/gemini.ts

@@ -1,6 +1,5 @@
 import { execa } from "execa";
 import chalk from "chalk";
-import { platform } from "os";
 import { existsSync } from "fs";
 import { createChildStdio, getTerminalStreams } from "./utils/terminal.js";
 
@@ -23,6 +22,7 @@ export async function launchGeminiCLI(
     mode?: "normal" | "continue" | "resume";
     extraArgs?: string[];
     envOverrides?: Record<string, string>;
+    model?: string;
   } = {},
 ): Promise<void> {
   const terminal = getTerminalStreams();
@@ -38,6 +38,11 @@ export async function launchGeminiCLI(
 
     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":
@@ -135,7 +140,7 @@ export async function launchGeminiCLI(
       errorMessage = `Failed to launch Gemini CLI: ${error.message || "Unknown error"}`;
     }
 
-    if (platform() === "win32") {
+    if (process.platform === "win32") {
       console.error(chalk.red("\n💡 Windows troubleshooting tips:"));
       if (hasLocalGemini) {
         console.error(
@@ -175,7 +180,7 @@ export async function launchGeminiCLI(
  */
 async function isGeminiCommandAvailable(): Promise<boolean> {
   try {
-    const command = platform() === "win32" ? "where" : "which";
+    const command = process.platform === "win32" ? "where" : "which";
     await execa(command, ["gemini"], { shell: true });
     return true;
   } catch {

package/src/index.ts

@@ -10,7 +10,11 @@ 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 {
@@ -183,17 +187,43 @@ async function runDependencyInstallStep<T extends DependencyInstallResult>(
 
 async function waitForEnter(promptMessage: string): Promise<void> {
   if (!process.stdin.isTTY) {
+    // For non-interactive environments, resolve immediately.
     return;
   }
 
+  // Ensure stdin is resumed and not in raw mode before using readline.
+  // This is crucial for environments where stdin might be paused or in raw mode
+  // by other libraries (like Ink.js).
+  if (typeof process.stdin.resume === "function") {
+    process.stdin.resume();
+  }
+  if (process.stdin.isRaw) {
+    process.stdin.setRawMode(false);
+  }
+
   await new Promise<void>((resolve) => {
     const rl = readline.createInterface({
       input: process.stdin,
       output: process.stdout,
     });
 
+    // Handle Ctrl+C to gracefully exit.
+    rl.on("SIGINT", () => {
+      rl.close();
+      // Restore stdin to a paused state before exiting.
+      if (typeof process.stdin.pause === "function") {
+        process.stdin.pause();
+      }
+      process.exit(0);
+    });
+
     rl.question(`${promptMessage}\n`, () => {
       rl.close();
+      // Pause stdin again to allow other parts of the application
+      // to take control if needed.
+      if (typeof process.stdin.pause === "function") {
+        process.stdin.pause();
+      }
       resolve();
     });
   });
@@ -292,11 +322,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 {
@@ -503,9 +539,11 @@ export async function handleAIToolWorkflow(
       printWarning(
         "Resolve these divergences (e.g., rebase or merge) before launching to avoid conflicts.",
       );
-      await waitForEnter("Press Enter to continue.");
+      await waitForEnter(
+        "Press Enter to return to the main menu and resolve these issues manually.",
+      );
       printWarning(
-        "Skipping AI tool launch until divergences are resolved. Returning to main menu...",
+        "AI tool launch has been cancelled until divergences are resolved.",
       );
       return;
     } else if (fastForwardError) {
@@ -528,7 +566,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"
@@ -537,9 +580,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"
@@ -548,9 +601,21 @@ 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") {
-      await launchGeminiCLI(worktreePath, {
+      const launchOptions: {
+        mode?: "normal" | "continue" | "resume";
+        skipPermissions?: boolean;
+        envOverrides?: Record<string, string>;
+        model?: string;
+      } = {
         mode:
           mode === "resume"
             ? "resume"
@@ -559,9 +624,18 @@ export async function handleAIToolWorkflow(
               : "normal",
         skipPermissions,
         envOverrides: sharedEnv,
-      });
+      };
+      if (model) {
+        launchOptions.model = model;
+      }
+      await launchGeminiCLI(worktreePath, launchOptions);
     } else if (tool === "qwen-cli") {
-      await launchQwenCLI(worktreePath, {
+      const launchOptions: {
+        mode?: "normal" | "continue" | "resume";
+        skipPermissions?: boolean;
+        envOverrides?: Record<string, string>;
+        model?: string;
+      } = {
         mode:
           mode === "resume"
             ? "resume"
@@ -570,7 +644,11 @@ export async function handleAIToolWorkflow(
               : "normal",
         skipPermissions,
         envOverrides: sharedEnv,
-      });
+      };
+      if (model) {
+        launchOptions.model = model;
+      }
+      await launchQwenCLI(worktreePath, launchOptions);
     } else {
       // Custom tool
       printInfo(`Launching custom tool: ${toolConfig.displayName}`);

package/src/qwen.ts

@@ -1,6 +1,5 @@
 import { execa } from "execa";
 import chalk from "chalk";
-import { platform } from "os";
 import { existsSync } from "fs";
 import { createChildStdio, getTerminalStreams } from "./utils/terminal.js";
 
@@ -23,6 +22,7 @@ export async function launchQwenCLI(
     mode?: "normal" | "continue" | "resume";
     extraArgs?: string[];
     envOverrides?: Record<string, string>;
+    model?: string;
   } = {},
 ): Promise<void> {
   const terminal = getTerminalStreams();
@@ -38,6 +38,11 @@ export async function launchQwenCLI(
 
     const args: string[] = ["--checkpointing"];
 
+    if (options.model) {
+      args.push("--model", options.model);
+      console.log(chalk.green(`   🎯 Model: ${options.model}`));
+    }
+
     // 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.
@@ -141,7 +146,7 @@ export async function launchQwenCLI(
       errorMessage = `Failed to launch Qwen CLI: ${error.message || "Unknown error"}`;
     }
 
-    if (platform() === "win32") {
+    if (process.platform === "win32") {
       console.error(chalk.red("\n💡 Windows troubleshooting tips:"));
       if (hasLocalQwen) {
         console.error(
@@ -181,7 +186,7 @@ export async function launchQwenCLI(
  */
 async function isQwenCommandAvailable(): Promise<boolean> {
   try {
-    const command = platform() === "win32" ? "where" : "which";
+    const command = process.platform === "win32" ? "where" : "which";
     await execa(command, ["qwen"], { shell: true });
     return true;
   } catch {