@akiojin/gwt 3.1.2 → 4.0.1

package/src/cli/ui/components/screens/ModelSelectorScreen.tsx

@@ -1,8 +1,9 @@
 import React, { useEffect, useMemo, useState } from "react";
-import { Box, Text, useInput } from "ink";
+import { Box, Text } from "ink";
 import { Header } from "../parts/Header.js";
 import { Footer } from "../parts/Footer.js";
 import { Select, type SelectItem } from "../common/Select.js";
+import { useAppInput } from "../../hooks/useAppInput.js";
 import { useTerminalSize } from "../../hooks/useTerminalSize.js";
 import type { AITool, InferenceLevel, ModelOption } from "../../types.js";
 import {
@@ -12,6 +13,9 @@ import {
   getModelOptions,
 } from "../../utils/modelOptions.js";
 
+/**
+ * Result returned by `ModelSelectorScreen`.
+ */
 export interface ModelSelectionResult {
   model: string | null;
   inferenceLevel?: InferenceLevel;
@@ -25,6 +29,9 @@ interface InferenceSelectItem extends SelectItem {
   hint?: string;
 }
 
+/**
+ * Props for `ModelSelectorScreen`.
+ */
 export interface ModelSelectorScreenProps {
   tool: AITool;
   onBack: () => void;
@@ -37,7 +44,6 @@ const TOOL_LABELS: Record<string, string> = {
   "claude-code": "Claude Code",
   "codex-cli": "Codex",
   "gemini-cli": "Gemini",
-  "qwen-cli": "Qwen",
 };
 
 const INFERENCE_LABELS: Record<InferenceLevel, string> = {
@@ -159,7 +165,7 @@ export function ModelSelectorScreen({
     return index >= 0 ? index : 0;
   }, [initialSelection?.inferenceLevel, inferenceOptions, selectedModel]);
 
-  useInput((_input, key) => {
+  useAppInput((_input, key) => {
     if (key.escape) {
       if (step === "inference") {
         setStep("model");
@@ -255,13 +261,6 @@ export function ModelSelectorScreen({
                 {modelOptions.length === 0 ? " (no options)" : ""}
               </Text>
             </Box>
-            {tool === "qwen-cli" ? (
-              <Box marginBottom={1} flexDirection="column">
-                <Text>Latest Qwen models from Alibaba Cloud ModelStudio:</Text>
-                <Text>• coder-model (qwen3-coder-plus-2025-09-23)</Text>
-                <Text>• vision-model (qwen3-vl-plus-2025-09-23)</Text>
-              </Box>
-            ) : null}
 
             {modelItems.length === 0 ? (
               <Select

package/src/cli/ui/components/screens/PRCleanupScreen.tsx

@@ -1,17 +1,24 @@
 import React from "react";
-import { Box, Text, useInput } from "ink";
+import { Box, Text } from "ink";
 import { Header } from "../parts/Header.js";
 import { Footer } from "../parts/Footer.js";
 import { Select } from "../common/Select.js";
+import { useAppInput } from "../../hooks/useAppInput.js";
 import { useTerminalSize } from "../../hooks/useTerminalSize.js";
 import type { CleanupTarget } from "../../types.js";
 
+/**
+ * Renderable item for the cleanup target list.
+ */
 export interface PRItem {
   label: string;
   value: string;
   target: CleanupTarget;
 }
 
+/**
+ * Props for `PRCleanupScreen`.
+ */
 export interface PRCleanupScreenProps {
   targets: CleanupTarget[];
   loading: boolean;
@@ -41,7 +48,7 @@ export function PRCleanupScreen({
 
   // Handle keyboard input
   // Note: Select component handles Enter and arrow keys
-  useInput((input, key) => {
+  useAppInput((input, key) => {
     if (key.escape) {
       onBack();
     } else if (input === "r") {

package/src/cli/ui/components/screens/SessionSelectorScreen.tsx

@@ -1,16 +1,23 @@
 import React from "react";
-import { Box, Text, useInput } from "ink";
+import { Box, Text } from "ink";
 import { Header } from "../parts/Header.js";
 import { Footer } from "../parts/Footer.js";
 import { Select } from "../common/Select.js";
+import { useAppInput } from "../../hooks/useAppInput.js";
 import { useTerminalSize } from "../../hooks/useTerminalSize.js";
 
+/**
+ * Renderable item for the session selector list.
+ */
 export interface SessionItem {
   label: string;
   value: string;
   secondary?: string;
 }
 
+/**
+ * Props for `SessionSelectorScreen`.
+ */
 export interface SessionSelectorScreenProps {
   sessions: {
     sessionId: string;
@@ -41,7 +48,7 @@ export function SessionSelectorScreen({
 
   // Handle keyboard input
   // Note: Select component handles Enter and arrow keys
-  useInput((input, key) => {
+  useAppInput((input, key) => {
     if (key.escape) {
       onBack();
     }

package/src/cli/ui/hooks/useAppInput.ts

@@ -0,0 +1,171 @@
+import { useCallback, useEffect, useRef } from "react";
+import { useInput, type Key } from "ink";
+
+const ESCAPE_SEQUENCE_TIMEOUT_MS = 25;
+
+type InputHandler = (input: string, key: Key) => void;
+type Options = { isActive?: boolean };
+
+type BufferedEvent = { input: string; key: Key };
+
+type PendingEscape = {
+  escapeEvent: BufferedEvent;
+  bufferedEvents: BufferedEvent[];
+  timeoutId: ReturnType<typeof setTimeout> | null;
+};
+
+const createEmptyKey = (): Key => ({
+  upArrow: false,
+  downArrow: false,
+  leftArrow: false,
+  rightArrow: false,
+  pageDown: false,
+  pageUp: false,
+  return: false,
+  escape: false,
+  ctrl: false,
+  shift: false,
+  tab: false,
+  backspace: false,
+  delete: false,
+  meta: false,
+});
+
+function parseArrowDirection(
+  sequence: string,
+): "up" | "down" | "left" | "right" | null {
+  if (!sequence) {
+    return null;
+  }
+
+  const first = sequence[0];
+  if (first !== "[" && first !== "O") {
+    return null;
+  }
+
+  const last = sequence.at(-1);
+  if (!last) {
+    return null;
+  }
+
+  switch (last.toUpperCase()) {
+    case "A":
+      return "up";
+    case "B":
+      return "down";
+    case "C":
+      return "right";
+    case "D":
+      return "left";
+    default:
+      return null;
+  }
+}
+
+/**
+ * Ink `useInput` wrapper that buffers an initial Escape press to disambiguate
+ * between a real Escape key and a split ANSI escape sequence (e.g., arrow keys
+ * in WSL2/Windows terminals).
+ *
+ * When an Escape is received, waits briefly for subsequent characters. If they
+ * form an arrow sequence (e.g., `[A`, `[B`, `OA`), emits a synthetic arrow
+ * `Key`. Otherwise, forwards the original Escape keypress.
+ *
+ * @param inputHandler - Callback invoked for each normalized input event
+ * @param options - Optional Ink input options (e.g., `{ isActive: false }`)
+ */
+export function useAppInput(
+  inputHandler: InputHandler,
+  options?: Options,
+): void {
+  const handlerRef = useRef(inputHandler);
+  const pendingRef = useRef<PendingEscape | null>(null);
+
+  useEffect(() => {
+    handlerRef.current = inputHandler;
+  }, [inputHandler]);
+
+  const clearPending = useCallback(() => {
+    const pending = pendingRef.current;
+    if (pending?.timeoutId) {
+      clearTimeout(pending.timeoutId);
+    }
+    pendingRef.current = null;
+  }, []);
+
+  const flushPending = useCallback(() => {
+    const pending = pendingRef.current;
+    if (!pending) {
+      return;
+    }
+
+    clearPending();
+    handlerRef.current(pending.escapeEvent.input, pending.escapeEvent.key);
+    for (const event of pending.bufferedEvents) {
+      handlerRef.current(event.input, event.key);
+    }
+  }, [clearPending]);
+
+  useEffect(() => {
+    if (options?.isActive === false) {
+      clearPending();
+    }
+  }, [options?.isActive, clearPending]);
+
+  useEffect(() => clearPending, [clearPending]);
+
+  useInput((input, key) => {
+    const pending = pendingRef.current;
+
+    if (!pending) {
+      if (key.escape) {
+        const timeoutId = setTimeout(flushPending, ESCAPE_SEQUENCE_TIMEOUT_MS);
+        pendingRef.current = {
+          escapeEvent: { input, key },
+          bufferedEvents: [],
+          timeoutId,
+        };
+        return;
+      }
+
+      handlerRef.current(input, key);
+      return;
+    }
+
+    if (pending.timeoutId) {
+      clearTimeout(pending.timeoutId);
+    }
+
+    pending.bufferedEvents.push({ input, key });
+
+    const [firstEvent] = pending.bufferedEvents;
+    const firstInput = firstEvent?.input;
+
+    if (firstInput && firstInput !== "[" && firstInput !== "O") {
+      flushPending();
+      return;
+    }
+
+    const sequence = pending.bufferedEvents
+      .map((event) => event.input)
+      .join("");
+    const arrow = parseArrowDirection(sequence);
+    if (arrow) {
+      clearPending();
+      const arrowKey = createEmptyKey();
+      if (arrow === "up") {
+        arrowKey.upArrow = true;
+      } else if (arrow === "down") {
+        arrowKey.downArrow = true;
+      } else if (arrow === "left") {
+        arrowKey.leftArrow = true;
+      } else if (arrow === "right") {
+        arrowKey.rightArrow = true;
+      }
+      handlerRef.current("", arrowKey);
+      return;
+    }
+
+    pending.timeoutId = setTimeout(flushPending, ESCAPE_SEQUENCE_TIMEOUT_MS);
+  }, options);
+}

package/src/cli/ui/screens/BranchActionSelectorScreen.tsx

@@ -1,9 +1,13 @@
 import React from "react";
-import { Box, Text, useInput } from "ink";
+import { Box, Text } from "ink";
 import { Select, type SelectItem } from "../components/common/Select.js";
 import { Footer } from "../components/parts/Footer.js";
+import { useAppInput } from "../hooks/useAppInput.js";
 import type { BranchAction } from "../types.js";
 
+/**
+ * Props for `BranchActionSelectorScreen`.
+ */
 export interface BranchActionSelectorScreenProps {
   selectedBranch: string;
   onUseExisting: () => void;
@@ -35,7 +39,7 @@ export function BranchActionSelectorScreen({
   secondaryLabel,
 }: BranchActionSelectorScreenProps) {
   // Handle keyboard input for back navigation
-  useInput((input, key) => {
+  useAppInput((input, key) => {
     if (key.escape) {
       onBack();
     }

package/src/cli/ui/screens/__tests__/BranchActionSelectorScreen.test.tsx

@@ -2,7 +2,8 @@
  * @vitest-environment happy-dom
  */
 import { describe, it, expect, beforeEach, vi } from "vitest";
-import { render } from "@testing-library/react";
+import { act, render } from "@testing-library/react";
+import { render as inkRender } from "ink-testing-library";
 import React from "react";
 import { BranchActionSelectorScreen } from "../BranchActionSelectorScreen.js";
 import { Window } from "happy-dom";
@@ -149,4 +150,70 @@ describe("BranchActionSelectorScreen", () => {
     // For now, we verify the component structure and callbacks are set up
     expect(onCreateNew).not.toHaveBeenCalled();
   });
+
+  it("should treat split down-arrow sequence as navigation (WSL2) and not as Escape", () => {
+    const onUseExisting = vi.fn();
+    const onCreateNew = vi.fn();
+    const onBack = vi.fn();
+
+    const inkApp = inkRender(
+      <BranchActionSelectorScreen
+        selectedBranch="feature-test"
+        onUseExisting={onUseExisting}
+        onCreateNew={onCreateNew}
+        onBack={onBack}
+      />,
+    );
+
+    act(() => {
+      inkApp.stdin.write("\u001b");
+      inkApp.stdin.write("[");
+      inkApp.stdin.write("B");
+    });
+
+    act(() => {
+      inkApp.stdin.write("\r");
+    });
+
+    expect(onBack).not.toHaveBeenCalled();
+    expect(onCreateNew).toHaveBeenCalledTimes(1);
+    expect(onUseExisting).not.toHaveBeenCalled();
+
+    inkApp.unmount();
+  });
+
+  it("should still handle Escape key as back navigation", () => {
+    vi.useFakeTimers();
+    let inkApp: ReturnType<typeof inkRender> | undefined;
+
+    try {
+      const onUseExisting = vi.fn();
+      const onCreateNew = vi.fn();
+      const onBack = vi.fn();
+
+      inkApp = inkRender(
+        <BranchActionSelectorScreen
+          selectedBranch="feature-test"
+          onUseExisting={onUseExisting}
+          onCreateNew={onCreateNew}
+          onBack={onBack}
+        />,
+      );
+
+      act(() => {
+        inkApp.stdin.write("\u001b");
+      });
+
+      act(() => {
+        vi.advanceTimersByTime(25);
+      });
+
+      expect(onBack).toHaveBeenCalledTimes(1);
+      expect(onCreateNew).not.toHaveBeenCalled();
+      expect(onUseExisting).not.toHaveBeenCalled();
+    } finally {
+      inkApp?.unmount();
+      vi.useRealTimers();
+    }
+  });
 });

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

@@ -98,7 +98,6 @@ function mapToolLabel(toolId: string, toolLabel?: string): string {
   if (toolId === "claude-code") return "Claude";
   if (toolId === "codex-cli") return "Codex";
   if (toolId === "gemini-cli") return "Gemini";
-  if (toolId === "qwen-cli") return "Qwen";
   if (toolLabel) return toolLabel;
   return "Custom";
 }

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

@@ -8,13 +8,13 @@ import {
 const byId = (tool: string) => getModelOptions(tool).map((m) => m.id);
 
 describe("modelOptions", () => {
-  it("lists Claude official aliases and sets Opus 4.5 as default", () => {
+  it("lists Claude official aliases and sets Default as default", () => {
     const options = getModelOptions("claude-code");
     const ids = options.map((m) => m.id);
-    expect(ids).toEqual(["opus", "sonnet", "haiku"]);
+    expect(ids).toEqual(["", "opus", "sonnet", "haiku"]);
     const defaultModel = getDefaultModelOption("claude-code");
-    expect(defaultModel?.id).toBe("opus");
-    expect(defaultModel?.label).toBe("Opus 4.5");
+    expect(defaultModel?.id).toBe("");
+    expect(defaultModel?.label).toBe("Default (Auto)");
   });
 
   it("has unique Codex models", () => {
@@ -22,6 +22,7 @@ describe("modelOptions", () => {
     const unique = new Set(ids);
     expect(unique.size).toBe(ids.length);
     expect(ids).toEqual([
+      "",
       "gpt-5.1-codex",
       "gpt-5.2",
       "gpt-5.1-codex-max",
@@ -52,14 +53,16 @@ describe("modelOptions", () => {
 
   it("lists expected Gemini models", () => {
     expect(byId("gemini-cli")).toEqual([
+      "",
       "gemini-3-pro-preview",
+      "gemini-3-flash-preview",
       "gemini-2.5-pro",
       "gemini-2.5-flash",
       "gemini-2.5-flash-lite",
     ]);
   });
 
-  it("lists expected Qwen models", () => {
-    expect(byId("qwen-cli")).toEqual(["coder-model", "vision-model"]);
+  it("returns no models for unsupported tools", () => {
+    expect(byId("unknown-tool")).toEqual([]);
   });
 });

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

@@ -5,12 +5,17 @@ const CODEX_MAX_LEVELS: InferenceLevel[] = ["xhigh", "high", "medium", "low"];
 
 const MODEL_OPTIONS: Record<string, ModelOption[]> = {
   "claude-code": [
+    {
+      id: "",
+      label: "Default (Auto)",
+      description: "Use Claude Code default behavior",
+      isDefault: true,
+    },
     {
       id: "opus",
       label: "Opus 4.5",
       description:
         "Official Opus alias for Claude Code (non-custom, matches /model option).",
-      isDefault: true,
     },
     {
       id: "sonnet",
@@ -25,13 +30,20 @@ const MODEL_OPTIONS: Record<string, ModelOption[]> = {
     },
   ],
   "codex-cli": [
+    {
+      id: "",
+      label: "Default (Auto)",
+      description: "Use Codex default model",
+      isDefault: true,
+      inferenceLevels: CODEX_BASE_LEVELS,
+      defaultInference: "high",
+    },
     {
       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.2",
@@ -63,12 +75,22 @@ const MODEL_OPTIONS: Record<string, ModelOption[]> = {
     },
   ],
   "gemini-cli": [
+    {
+      id: "",
+      label: "Default (Auto)",
+      description: "Use Gemini CLI default model",
+      isDefault: true,
+    },
     {
       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-3-flash-preview",
+      label: "Flash (gemini-3-flash-preview)",
+      description: "Next-generation high-speed model",
     },
     {
       id: "gemini-2.5-pro",
@@ -86,21 +108,6 @@ const MODEL_OPTIONS: Record<string, ModelOption[]> = {
       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[] {

package/src/codex.ts

@@ -2,16 +2,36 @@ import { execa } from "execa";
 import chalk from "chalk";
 import { platform } from "os";
 import { existsSync } from "fs";
-import { createChildStdio, getTerminalStreams } from "./utils/terminal.js";
+import {
+  createChildStdio,
+  getTerminalStreams,
+  resetTerminalModes,
+} from "./utils/terminal.js";
 import { findLatestCodexSession } from "./utils/session.js";
 
 const CODEX_CLI_PACKAGE = "@openai/codex@latest";
 
+/**
+ * Reasoning effort levels supported by Codex CLI.
+ */
 export type CodexReasoningEffort = "low" | "medium" | "high" | "xhigh";
 
+/**
+ * Default Codex model used when no override is provided.
+ */
 export const DEFAULT_CODEX_MODEL = "gpt-5.1-codex";
+
+/**
+ * Default reasoning effort used when no override is provided.
+ */
 export const DEFAULT_CODEX_REASONING_EFFORT: CodexReasoningEffort = "high";
 
+/**
+ * Builds the default argument list for Codex CLI launch.
+ *
+ * @param model - Model name to pass via `--model`
+ * @param reasoningEffort - Reasoning effort to pass via config
+ */
 export const buildDefaultCodexArgs = (
   model: string = DEFAULT_CODEX_MODEL,
   reasoningEffort: CodexReasoningEffort = DEFAULT_CODEX_REASONING_EFFORT,
@@ -37,6 +57,10 @@ export const buildDefaultCodexArgs = (
   "shell_environment_policy.experimental_use_profile=true",
 ];
 
+/**
+ * Error wrapper used by `launchCodexCLI` to preserve the original failure
+ * while providing a user-friendly message.
+ */
 export class CodexError extends Error {
   constructor(
     message: string,
@@ -47,6 +71,16 @@ export class CodexError extends Error {
   }
 }
 
+/**
+ * Launches Codex CLI in the given worktree path.
+ *
+ * This function resets terminal modes before and after the child process and
+ * tries to detect a session id after launch (when supported).
+ *
+ * @param worktreePath - Worktree directory to run Codex CLI in
+ * @param options - Launch options (mode/session/model/reasoning/env)
+ * @returns Captured session id when available
+ */
 export async function launchCodexCLI(
   worktreePath: string,
   options: {
@@ -133,6 +167,7 @@ export async function launchCodexCLI(
     console.log(chalk.gray(`   📋 Args: ${args.join(" ")}`));
 
     terminal.exitRawMode();
+    resetTerminalModes(terminal.stdout);
 
     const childStdio = createChildStdio();
 
@@ -235,9 +270,13 @@ export async function launchCodexCLI(
     throw new CodexError(errorMessage, error);
   } finally {
     terminal.exitRawMode();
+    resetTerminalModes(terminal.stdout);
   }
 }
 
+/**
+ * Checks whether Codex CLI is available via `bunx` in the current environment.
+ */
 export async function isCodexAvailable(): Promise<boolean> {
   try {
     await execa("bunx", [CODEX_CLI_PACKAGE, "--help"]);

package/src/config/builtin-tools.ts

@@ -1,7 +1,7 @@
 /**
  * ビルトインAIツール定義
  *
- * Claude Code、Codex、Gemini、Qwen の CustomAITool 形式定義
+ * Claude Code、Codex、Gemini の CustomAITool 形式定義
  */
 
 import type { CustomAITool } from "../types/tools.js";
@@ -58,23 +58,6 @@ export const GEMINI_CLI_TOOL: CustomAITool = {
   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"],
-};
-
 /**
  * すべてのビルトインツール
  */
@@ -82,5 +65,4 @@ export const BUILTIN_TOOLS: CustomAITool[] = [
   CLAUDE_CODE_TOOL,
   CODEX_CLI_TOOL,
   GEMINI_CLI_TOOL,
-  QWEN_CLI_TOOL,
 ];