@akiojin/gwt 2.3.0 → 2.4.1

package/src/cli/ui/components/App.tsx

@@ -14,14 +14,23 @@ import { BranchActionSelectorScreen } from "../screens/BranchActionSelectorScree
 import { AIToolSelectorScreen } from "./screens/AIToolSelectorScreen.js";
 import { SessionSelectorScreen } from "./screens/SessionSelectorScreen.js";
 import { ExecutionModeSelectorScreen } from "./screens/ExecutionModeSelectorScreen.js";
-import type { AITool } from "./screens/AIToolSelectorScreen.js";
 import type { ExecutionMode } from "./screens/ExecutionModeSelectorScreen.js";
+import {
+  ModelSelectorScreen,
+  type ModelSelectionResult,
+} from "./screens/ModelSelectorScreen.js";
 import type { WorktreeItem } from "./screens/WorktreeManagerScreen.js";
 import { useGitData } from "../hooks/useGitData.js";
 import { useScreenState } from "../hooks/useScreenState.js";
 import { formatBranchItems } from "../utils/branchFormatter.js";
 import { calculateStatistics } from "../utils/statisticsCalculator.js";
-import type { BranchInfo, BranchItem, SelectedBranchState } from "../types.js";
+import type {
+  AITool,
+  BranchInfo,
+  BranchItem,
+  InferenceLevel,
+  SelectedBranchState,
+} from "../types.js";
 import { getRepositoryRoot, deleteBranch } from "../../../git.js";
 import {
   createWorktree,
@@ -36,6 +45,10 @@ import {
   resolveBaseBranchLabel,
   resolveBaseBranchRef,
 } from "../utils/baseBranch.js";
+import {
+  getDefaultInferenceForModel,
+  getDefaultModelOption,
+} from "../utils/modelOptions.js";
 
 const SPINNER_FRAMES = ["⠋", "⠙", "⠹", "⠸", "⠼", "⠴", "⠦", "⠧"];
 const COMPLETION_HOLD_DURATION_MS = 3000;
@@ -58,6 +71,8 @@ export interface SelectionResult {
   tool: AITool;
   mode: ExecutionMode;
   skipPermissions: boolean;
+  model?: string | null;
+  inferenceLevel?: InferenceLevel;
 }
 
 export interface AppProps {
@@ -90,6 +105,11 @@ export function App({ onExit, loadingIndicatorDelay = 300 }: AppProps) {
   const [creationSourceBranch, setCreationSourceBranch] =
     useState<SelectedBranchState | null>(null);
   const [selectedTool, setSelectedTool] = useState<AITool | null>(null);
+  const [selectedModel, setSelectedModel] =
+    useState<ModelSelectionResult | null>(null);
+  const [lastModelByTool, setLastModelByTool] = useState<
+    Record<AITool, ModelSelectionResult | undefined>
+  >({});
 
   // PR cleanup feedback
   const [cleanupIndicators, setCleanupIndicators] = useState<
@@ -365,6 +385,7 @@ export function App({ onExit, loadingIndicatorDelay = 300 }: AppProps) {
 
       setSelectedBranch(selection);
       setSelectedTool(null);
+      setSelectedModel(null);
       setCreationSourceBranch(null);
 
       if (protectedSelected) {
@@ -405,6 +426,7 @@ export function App({ onExit, loadingIndicatorDelay = 300 }: AppProps) {
         branchCategory: inferBranchCategory(worktree.branch),
       });
       setSelectedTool(null);
+      setSelectedModel(null);
       setCreationSourceBranch(null);
       setCleanupFooterMessage(null);
       navigateTo("ai-tool-selector");
@@ -518,6 +540,7 @@ export function App({ onExit, loadingIndicatorDelay = 300 }: AppProps) {
           branchCategory: inferBranchCategory(branchName),
         });
         setSelectedTool(null);
+        setSelectedModel(null);
         setCleanupFooterMessage(null);
 
         navigateTo("ai-tool-selector");
@@ -726,9 +749,22 @@ export function App({ onExit, loadingIndicatorDelay = 300 }: AppProps) {
   const handleToolSelect = useCallback(
     (tool: AITool) => {
       setSelectedTool(tool);
+      setSelectedModel(lastModelByTool[tool] ?? null);
+      navigateTo("model-selector");
+    },
+    [lastModelByTool, navigateTo],
+  );
+
+  const handleModelSelect = useCallback(
+    (selection: ModelSelectionResult) => {
+      setSelectedModel(selection);
+      setLastModelByTool((prev) => ({
+        ...prev,
+        ...(selectedTool ? { [selectedTool]: selection } : {}),
+      }));
       navigateTo("execution-mode-selector");
     },
-    [navigateTo],
+    [navigateTo, selectedTool],
   );
 
   // Handle session selection
@@ -746,6 +782,23 @@ export function App({ onExit, loadingIndicatorDelay = 300 }: AppProps) {
     (result: { mode: ExecutionMode; skipPermissions: boolean }) => {
       // All selections complete - exit with result
       if (selectedBranch && selectedTool) {
+        const defaultModel = getDefaultModelOption(selectedTool);
+        const resolvedModel =
+          selectedModel?.model ?? defaultModel?.id ?? null;
+        const resolvedInference =
+          selectedModel?.inferenceLevel ??
+          getDefaultInferenceForModel(defaultModel ?? undefined);
+
+        // Claude Code のデフォルトはモデル未指定が最も安定するため、default/sonnet/現行推奨IDの場合は --model を付けない
+        const isClaudeDefaultModel =
+          selectedTool === "claude-code" &&
+          (!resolvedModel ||
+            resolvedModel === "default" ||
+            resolvedModel === "sonnet" ||
+            resolvedModel === "claude-sonnet-4-5-20250929");
+
+        const modelForPayload = isClaudeDefaultModel ? undefined : resolvedModel;
+
         const payload: SelectionResult = {
           branch: selectedBranch.name,
           displayName: selectedBranch.displayName,
@@ -753,6 +806,10 @@ export function App({ onExit, loadingIndicatorDelay = 300 }: AppProps) {
           tool: selectedTool,
           mode: result.mode,
           skipPermissions: result.skipPermissions,
+          ...(modelForPayload !== undefined ? { model: modelForPayload } : {}),
+          ...(resolvedInference !== undefined
+            ? { inferenceLevel: resolvedInference }
+            : {}),
           ...(selectedBranch.remoteBranch
             ? { remoteBranch: selectedBranch.remoteBranch }
             : {}),
@@ -762,7 +819,15 @@ export function App({ onExit, loadingIndicatorDelay = 300 }: AppProps) {
         exit();
       }
     },
-    [selectedBranch, selectedTool, onExit, exit],
+    [
+      selectedBranch,
+      selectedTool,
+      selectedModel,
+      onExit,
+      exit,
+      getDefaultModelOption,
+      getDefaultInferenceForModel,
+    ],
   );
 
   // Render screen based on currentScreen
@@ -846,6 +911,21 @@ export function App({ onExit, loadingIndicatorDelay = 300 }: AppProps) {
           />
         );
 
+      case "model-selector":
+        if (!selectedTool) {
+          goBack();
+          return null;
+        }
+        return (
+          <ModelSelectorScreen
+            tool={selectedTool}
+            onBack={goBack}
+            onSelect={handleModelSelect}
+            version={version}
+            initialSelection={selectedModel}
+          />
+        );
+
       case "session-selector":
         // TODO: Implement session data fetching
         return (

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

@@ -6,8 +6,7 @@ import { Select } from "../common/Select.js";
 import { useTerminalSize } from "../../hooks/useTerminalSize.js";
 import { getAllTools } from "../../../../config/tools.js";
 import type { AIToolConfig } from "../../../../types/tools.js";
-
-export type AITool = string;
+import type { AITool } from "../../types.js";
 
 export interface AIToolItem {
   label: string;

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

@@ -147,6 +147,11 @@ export function BranchListScreen({
       return;
     }
 
+    // Disable global shortcuts while in filter mode
+    if (filterMode) {
+      return;
+    }
+
     // Global shortcuts (blocked by Input component when typing in filter mode)
     if (input === "m" && onNavigate) {
       onNavigate("worktree-manager");

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

@@ -0,0 +1,320 @@
+import React, { useEffect, useMemo, useState } from "react";
+import { Box, Text, useInput } from "ink";
+import { Header } from "../parts/Header.js";
+import { Footer } from "../parts/Footer.js";
+import { Select, type SelectItem } from "../common/Select.js";
+import { useTerminalSize } from "../../hooks/useTerminalSize.js";
+import type { AITool, InferenceLevel, ModelOption } from "../../types.js";
+import {
+  getDefaultInferenceForModel,
+  getDefaultModelOption,
+  getInferenceLevelsForModel,
+  getModelOptions,
+} from "../../utils/modelOptions.js";
+
+export interface ModelSelectionResult {
+  model: string | null;
+  inferenceLevel?: InferenceLevel;
+}
+
+interface ModelSelectItem extends SelectItem {
+  description?: string;
+}
+
+interface InferenceSelectItem extends SelectItem {
+  hint?: string;
+}
+
+export interface ModelSelectorScreenProps {
+  tool: AITool;
+  onBack: () => void;
+  onSelect: (selection: ModelSelectionResult) => void;
+  version?: string | null;
+  initialSelection?: ModelSelectionResult | null;
+}
+
+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> = {
+  low: "Low (lighter reasoning)",
+  medium: "Medium (balanced reasoning)",
+  high: "High (deeper reasoning)",
+  xhigh: "Extra high (maximum reasoning)",
+};
+
+/**
+ * モデル選択 → (必要なら) 推論レベル選択を行う画面
+ */
+export function ModelSelectorScreen({
+  tool,
+  onBack,
+  onSelect,
+  version,
+  initialSelection,
+}: ModelSelectorScreenProps) {
+  const { rows } = useTerminalSize();
+
+  const [step, setStep] = useState<"model" | "inference">("model");
+  const [modelOptions, setModelOptions] = useState<ModelOption[]>([]);
+  const [selectedModel, setSelectedModel] = useState<ModelOption | null>(null);
+
+  // モデル候補をツールに応じてロード
+  useEffect(() => {
+    const options = getModelOptions(tool);
+    setModelOptions(options);
+    // 初期選択が有効なら保持
+    if (initialSelection?.model) {
+      const found = options.find((opt) => opt.id === initialSelection.model);
+      if (found) {
+        setSelectedModel(found);
+        setStep("model");
+        return;
+      }
+    }
+    setSelectedModel(null);
+    setStep("model");
+  }, [tool, initialSelection?.model]);
+
+  const modelItems: ModelSelectItem[] = useMemo(
+    () =>
+      modelOptions.map((option) => ({
+        label: option.label,
+        value: option.id,
+        ...(option.description ? { description: option.description } : {}),
+      })),
+    [modelOptions],
+  );
+
+  const defaultModelIndex = useMemo(() => {
+    const initial = initialSelection?.model
+      ? modelOptions.findIndex((opt) => opt.id === initialSelection.model)
+      : -1;
+    if (initial !== -1) return initial;
+    const defaultOption = getDefaultModelOption(tool);
+    if (!defaultOption) return 0;
+    const index = modelOptions.findIndex((opt) => opt.id === defaultOption.id);
+    return index >= 0 ? index : 0;
+  }, [initialSelection?.model, modelOptions, tool]);
+
+  const inferenceOptions = useMemo(
+    () => getInferenceLevelsForModel(selectedModel ?? undefined),
+    [selectedModel],
+  );
+
+  const inferenceItems: InferenceSelectItem[] = useMemo(
+    () => {
+      return inferenceOptions.map((level) => {
+        if (selectedModel?.id === "gpt-5.1-codex-max") {
+          if (level === "low") {
+            return {
+              label: "Low",
+              value: level,
+              hint: "Fast responses with lighter reasoning",
+            };
+          }
+          if (level === "medium") {
+            return {
+              label: "Medium (default)",
+              value: level,
+              hint: "Balances speed and reasoning depth for everyday tasks",
+            };
+          }
+          if (level === "high") {
+            return {
+              label: "High",
+              value: level,
+              hint: "Maximizes reasoning depth for complex problems",
+            };
+          }
+          if (level === "xhigh") {
+            return {
+              label: "Extra high",
+              value: level,
+              hint:
+                "Extra high reasoning depth; may quickly consume Plus plan rate limits.",
+            };
+          }
+        }
+
+        return {
+          label: INFERENCE_LABELS[level],
+          value: level,
+        };
+      });
+    },
+    [inferenceOptions, selectedModel?.id],
+  );
+
+  const defaultInferenceIndex = useMemo(() => {
+    const initialLevel = initialSelection?.inferenceLevel;
+    if (initialLevel && inferenceOptions.includes(initialLevel)) {
+      return inferenceOptions.findIndex((lvl) => lvl === initialLevel);
+    }
+    const defaultLevel = getDefaultInferenceForModel(selectedModel ?? undefined);
+    if (!defaultLevel) return 0;
+    const index = inferenceOptions.findIndex((lvl) => lvl === defaultLevel);
+    return index >= 0 ? index : 0;
+  }, [initialSelection?.inferenceLevel, inferenceOptions, selectedModel]);
+
+  useInput((_input, key) => {
+    if (key.escape) {
+      if (step === "inference") {
+        setStep("model");
+        return;
+      }
+      onBack();
+    }
+  });
+
+  const handleModelSelect = (item: ModelSelectItem) => {
+    const option =
+      modelOptions.find((opt) => opt.id === item.value) ?? modelOptions[0];
+
+    if (!option) {
+      onSelect({ model: null });
+      return;
+    }
+
+    setSelectedModel(option);
+
+    const levels = getInferenceLevelsForModel(option);
+    if (levels.length > 0) {
+      setStep("inference");
+    } else {
+      onSelect({ model: option.id });
+    }
+  };
+
+  const handleInferenceSelect = (item: InferenceSelectItem) => {
+    if (!selectedModel) {
+      setStep("model");
+      return;
+    }
+
+    onSelect({
+      model: selectedModel.id,
+      inferenceLevel: item.value as InferenceLevel,
+    });
+  };
+
+  const footerActions =
+    step === "model"
+      ? [
+          { key: "enter", description: "Select" },
+          { key: "esc", description: "Back" },
+        ]
+      : [
+          { key: "enter", description: "Select" },
+          { key: "esc", description: "Back to model" },
+        ];
+
+  const toolLabel = TOOL_LABELS[tool] ?? tool;
+
+  const renderModelItem = (
+    item: ModelSelectItem,
+    isSelected: boolean,
+  ): React.ReactNode => (
+    <Box flexDirection="column">
+      {isSelected ? (
+        <Text color="cyan">➤ {item.label}</Text>
+      ) : (
+        <Text>  {item.label}</Text>
+      )}
+      {item.description ? (
+        <Text color="gray">    {item.description}</Text>
+      ) : null}
+    </Box>
+  );
+
+  return (
+    <Box flexDirection="column" height={rows}>
+      <Header
+        title={step === "model" ? "Model Selection" : "Inference Level"}
+        titleColor="blue"
+        version={version}
+      />
+
+      <Box flexDirection="column" flexGrow={1} marginTop={1}>
+        {step === "model" ? (
+          <>
+            {tool === "gemini-cli" ? (
+              <Box marginBottom={1} flexDirection="column">
+                <Text>Gemini 3 preview is enabled.</Text>
+                <Text>
+                  Selecting Pro uses gemini-3-pro-preview and falls back to
+                  gemini-2.5-pro if unavailable.
+                </Text>
+                <Text>Use --model to pin a specific Gemini model.</Text>
+              </Box>
+            ) : null}
+
+            <Box marginBottom={1}>
+              <Text>
+                Select a model for {toolLabel}
+                {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
+                items={[
+                  {
+                    label: "No model selection required. Press Enter to continue.",
+                    value: "__continue__",
+                  },
+                ]}
+                onSelect={() => onSelect({ model: null })}
+              />
+            ) : (
+              <Select
+                items={modelItems}
+                onSelect={handleModelSelect}
+                initialIndex={defaultModelIndex}
+                renderItem={renderModelItem}
+              />
+            )}
+          </>
+        ) : (
+          <>
+            <Box marginBottom={1}>
+              <Text>
+                Select reasoning level for {selectedModel?.label ?? "model"}
+              </Text>
+            </Box>
+            <Select
+              items={inferenceItems}
+              onSelect={handleInferenceSelect}
+              initialIndex={defaultInferenceIndex}
+              renderItem={(item, isSelected) => (
+                <Box flexDirection="column">
+                  {isSelected ? (
+                    <Text color="cyan">➤ {item.label}</Text>
+                  ) : (
+                    <Text>  {item.label}</Text>
+                  )}
+                  {"hint" in item && item.hint ? (
+                    <Text color="gray">    {item.hint}</Text>
+                  ) : null}
+                </Box>
+              )}
+            />
+          </>
+        )}
+      </Box>
+
+      <Footer actions={footerActions} />
+    </Box>
+  );
+}

package/src/cli/ui/types.ts

@@ -5,6 +5,18 @@ export interface WorktreeInfo {
   isAccessible?: boolean;
 }
 
+export type AITool = string;
+export type InferenceLevel = "low" | "medium" | "high" | "xhigh";
+
+export interface ModelOption {
+  id: string;
+  label: string;
+  description?: string;
+  inferenceLevels?: InferenceLevel[];
+  defaultInference?: InferenceLevel;
+  isDefault?: boolean;
+}
+
 export interface BranchInfo {
   name: string;
   type: "local" | "remote";
@@ -161,6 +173,7 @@ export type ScreenType =
   | "branch-creator"
   | "branch-action-selector"
   | "ai-tool-selector"
+  | "model-selector"
   | "session-selector"
   | "execution-mode-selector"
   | "batch-merge-progress"

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

@@ -0,0 +1,51 @@
+import { describe, it, expect } from "vitest";
+import {
+  getModelOptions,
+  getDefaultInferenceForModel,
+  getDefaultModelOption,
+} from "./modelOptions.js";
+
+const byId = (tool: string) => getModelOptions(tool).map((m) => m.id);
+
+describe("modelOptions", () => {
+  it("lists Claude official aliases and keeps default as recommended Sonnet 4.5", () => {
+    const ids = byId("claude-code");
+    expect(ids).toEqual([
+      "default",
+      "opus",
+      "haiku",
+    ]);
+    const defaultModel = getDefaultModelOption("claude-code");
+    expect(defaultModel?.id).toBe("default");
+  });
+
+  it("has unique Codex models", () => {
+    const ids = byId("codex-cli");
+    const unique = new Set(ids);
+    expect(unique.size).toBe(ids.length);
+    expect(ids).toEqual([
+      "gpt-5.1-codex",
+      "gpt-5.1-codex-max",
+      "gpt-5.1-codex-mini",
+      "gpt-5.1",
+    ]);
+  });
+
+  it("uses medium as default reasoning for codex-max", () => {
+    const codexMax = getModelOptions("codex-cli").find((m) => m.id === "gpt-5.1-codex-max");
+    expect(getDefaultInferenceForModel(codexMax)).toBe("medium");
+  });
+
+  it("lists expected Gemini models", () => {
+    expect(byId("gemini-cli")).toEqual([
+      "gemini-3-pro-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"]);
+  });
+});