@akiojin/gwt 4.0.0 → 4.1.0

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

@@ -23,12 +23,24 @@ describe("modelOptions", () => {
     expect(unique.size).toBe(ids.length);
     expect(ids).toEqual([
       "",
-      "gpt-5.1-codex",
-      "gpt-5.2",
+      "gpt-5.2-codex",
       "gpt-5.1-codex-max",
       "gpt-5.1-codex-mini",
-      "gpt-5.1",
+      "gpt-5.2",
+    ]);
+  });
+
+  it("exposes gpt-5.2-codex with xhigh reasoning and high default", () => {
+    const codex52 = getModelOptions("codex-cli").find(
+      (m) => m.id === "gpt-5.2-codex",
+    );
+    expect(codex52?.inferenceLevels).toEqual([
+      "xhigh",
+      "high",
+      "medium",
+      "low",
     ]);
+    expect(getDefaultInferenceForModel(codex52)).toBe("high");
   });
 
   it("uses medium as default reasoning for codex-max", () => {
@@ -63,6 +75,6 @@ describe("modelOptions", () => {
   });
 
   it("returns no models for unsupported tools", () => {
-    expect(byId("qwen-cli")).toEqual([]);
+    expect(byId("unknown-tool")).toEqual([]);
   });
 });

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

@@ -39,39 +39,33 @@ const MODEL_OPTIONS: Record<string, ModelOption[]> = {
       defaultInference: "high",
     },
     {
-      id: "gpt-5.1-codex",
-      label: "gpt-5.1-codex",
-      description: "Standard Codex model",
-      inferenceLevels: CODEX_BASE_LEVELS,
-      defaultInference: "high",
-    },
-    {
-      id: "gpt-5.2",
-      label: "gpt-5.2",
-      description: "Latest frontier model with extra high reasoning",
+      id: "gpt-5.2-codex",
+      label: "gpt-5.2-codex",
+      description: "Latest frontier agentic coding model",
       inferenceLevels: CODEX_MAX_LEVELS,
-      defaultInference: "medium",
+      defaultInference: "high",
     },
     {
       id: "gpt-5.1-codex-max",
       label: "gpt-5.1-codex-max",
-      description: "Max performance (xhigh available)",
+      description: "Codex-optimized flagship for deep and fast reasoning.",
       inferenceLevels: CODEX_MAX_LEVELS,
       defaultInference: "medium",
     },
     {
       id: "gpt-5.1-codex-mini",
       label: "gpt-5.1-codex-mini",
-      description: "Lightweight / cost-saving",
+      description: "Optimized for codex. Cheaper, faster, but less capable.",
       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",
+      id: "gpt-5.2",
+      label: "gpt-5.2",
+      description:
+        "Latest frontier model with improvements across knowledge, reasoning and coding",
+      inferenceLevels: CODEX_MAX_LEVELS,
+      defaultInference: "medium",
     },
   ],
   "gemini-cli": [

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";
 
-export const DEFAULT_CODEX_MODEL = "gpt-5.1-codex";
+/**
+ * Default Codex model used when no override is provided.
+ */
+export const DEFAULT_CODEX_MODEL = "gpt-5.2-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,25 +58,6 @@ export const GEMINI_CLI_TOOL: CustomAITool = {
   permissionSkipArgs: ["-y"],
 };
 
-/**
- * Qwen のビルトイン定義
- *
- * NOTE: 現在は未サポート（選択画面には表示しない）。ID予約のため定義のみ残す。
- */
-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"],
-};
-
 /**
  * すべてのビルトインツール
  */
@@ -84,5 +65,4 @@ export const BUILTIN_TOOLS: CustomAITool[] = [
   CLAUDE_CODE_TOOL,
   CODEX_CLI_TOOL,
   GEMINI_CLI_TOOL,
-  QWEN_CLI_TOOL,
 ];

package/src/config/tools.ts

@@ -299,17 +299,13 @@ export async function getToolById(
 export async function getAllTools(): Promise<AIToolConfig[]> {
   const config = await loadToolsConfig();
 
-  // Builtin tools that are reserved but not exposed in selectors.
-  // These IDs remain blocked from customTools to avoid ambiguity.
-  const UNSUPPORTED_BUILTIN_TOOL_IDS = new Set<string>(["qwen-cli"]);
-
   // ビルトインツールをAIToolConfig形式に変換
   const builtinConfigs: AIToolConfig[] = BUILTIN_TOOLS.map((tool) => ({
     id: tool.id,
     displayName: tool.displayName,
     ...(tool.icon ? { icon: tool.icon } : {}),
     isBuiltin: true,
-  })).filter((tool) => !UNSUPPORTED_BUILTIN_TOOL_IDS.has(tool.id));
+  }));
 
   // カスタムツールをAIToolConfig形式に変換
   const customConfigs: AIToolConfig[] = config.customTools.map((tool) => ({

package/src/gemini.ts

@@ -1,11 +1,20 @@
 import { execa } from "execa";
 import chalk from "chalk";
 import { existsSync } from "fs";
-import { createChildStdio, getTerminalStreams } from "./utils/terminal.js";
+import {
+  createChildStdio,
+  getTerminalStreams,
+  resetTerminalModes,
+} from "./utils/terminal.js";
+import { isCommandAvailable } from "./utils/command.js";
 import { findLatestGeminiSessionId } from "./utils/session.js";
 
 const GEMINI_CLI_PACKAGE = "@google/gemini-cli@latest";
 
+/**
+ * Error wrapper used by `launchGeminiCLI` to preserve the original failure
+ * while providing a user-friendly message.
+ */
 export class GeminiError extends Error {
   constructor(
     message: string,
@@ -16,6 +25,16 @@ export class GeminiError extends Error {
   }
 }
 
+/**
+ * Launches Gemini CLI in the given worktree path.
+ *
+ * This function resets terminal modes before and after the child process and
+ * supports continue/resume modes when a session id is available.
+ *
+ * @param worktreePath - Worktree directory to run Gemini CLI in
+ * @param options - Launch options (mode/session/model/permissions/env)
+ * @returns Captured session id when available
+ */
 export async function launchGeminiCLI(
   worktreePath: string,
   options: {
@@ -119,6 +138,7 @@ export async function launchGeminiCLI(
       );
     }
     terminal.exitRawMode();
+    resetTerminalModes(terminal.stdout);
 
     const baseEnv = Object.fromEntries(
       Object.entries({
@@ -132,7 +152,7 @@ export async function launchGeminiCLI(
     const childStdio = createChildStdio();
 
     // Auto-detect locally installed gemini command
-    const hasLocalGemini = await isGeminiCommandAvailable();
+    const hasLocalGemini = await isCommandAvailable("gemini");
 
     // Preserve TTY for interactive UI (colors/width) by inheriting stdout/stderr.
     // Session ID is determined via file-based detection after exit.
@@ -243,7 +263,7 @@ export async function launchGeminiCLI(
 
     return capturedSessionId ? { sessionId: capturedSessionId } : {};
   } catch (error: unknown) {
-    const hasLocalGemini = await isGeminiCommandAvailable();
+    const hasLocalGemini = await isCommandAvailable("gemini");
     let errorMessage: string;
     const err = error as NodeJS.ErrnoException;
 
@@ -291,29 +311,13 @@ export async function launchGeminiCLI(
     throw new GeminiError(errorMessage, error);
   } finally {
     terminal.exitRawMode();
+    resetTerminalModes(terminal.stdout);
   }
 }
 
 /**
- * Check if locally installed `gemini` command is available
- * @returns true if `gemini` command exists in PATH, false otherwise
+ * Checks whether Gemini CLI is available via `bunx` in the current environment.
  */
-async function isGeminiCommandAvailable(): Promise<boolean> {
-  try {
-    const command = process.platform === "win32" ? "where" : "which";
-    await execa(command, ["gemini"], {
-      shell: true,
-      stdin: "ignore",
-      stdout: "ignore",
-      stderr: "ignore",
-    });
-    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 });

package/src/index.ts

@@ -307,12 +307,6 @@ export async function handleAIToolWorkflow(
     `Selected: ${branchLabel} with ${tool} (${mode} mode${modelInfo}, skipPermissions: ${skipPermissions})`,
   );
 
-  if (tool === "qwen-cli") {
-    printError("Qwen CLI is currently unsupported.");
-    await waitForErrorAcknowledgement();
-    return;
-  }
-
   try {
     // Get repository root
     const repoRootResult = await runGitStep("retrieve repository root", () =>

package/src/shared/aiToolConstants.ts

@@ -12,7 +12,7 @@ export const CLAUDE_PERMISSION_SKIP_ARGS = [
 export const CODEX_DEFAULT_ARGS = [
   "--enable",
   "web_search_request",
-  "--model=gpt-5-codex",
+  "--model=gpt-5.2-codex",
   "--sandbox",
   "workspace-write",
   "-c",

package/src/utils/command.ts

@@ -0,0 +1,26 @@
+import { execa } from "execa";
+
+/**
+ * Checks whether a command is available in the current PATH.
+ *
+ * Uses `where` on Windows and `which` on other platforms.
+ *
+ * @param commandName - Command name to look up (e.g. `claude`, `npx`, `gemini`)
+ * @returns true if the command exists in PATH
+ */
+export async function isCommandAvailable(
+  commandName: string,
+): Promise<boolean> {
+  try {
+    const command = process.platform === "win32" ? "where" : "which";
+    await execa(command, [commandName], {
+      shell: true,
+      stdin: "ignore",
+      stdout: "ignore",
+      stderr: "ignore",
+    });
+    return true;
+  } catch {
+    return false;
+  }
+}

package/src/utils/session/index.ts

@@ -5,7 +5,6 @@
  * - Claude Code
  * - Codex CLI
  * - Gemini CLI
- * - Qwen CLI
  */
 
 // Type exports
@@ -41,6 +40,3 @@ export {
   findLatestGeminiSession,
   findLatestGeminiSessionId,
 } from "./parsers/gemini.js";
-
-// Qwen CLI parser
-export { findLatestQwenSessionId } from "./parsers/qwen.js";

package/src/utils/session/parsers/index.ts

@@ -23,6 +23,3 @@ export {
   findLatestGeminiSession,
   findLatestGeminiSessionId,
 } from "./gemini.js";
-
-// Qwen CLI
-export { findLatestQwenSessionId } from "./qwen.js";