@akiojin/gwt 2.3.0 → 2.4.0

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,36 @@
+import { describe, it, expect } from "vitest";
+import { getModelOptions, getDefaultInferenceForModel } from "./modelOptions.js";
+
+const byId = (tool: string) => getModelOptions(tool).map((m) => m.id);
+
+describe("modelOptions", () => {
+  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"]);
+  });
+});

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

@@ -0,0 +1,122 @@
+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: "claude-sonnet-4.5",
+      label: "Default (recommended) — Sonnet 4.5",
+      description: "Smartest model for daily use (released Sep 29, 2025)",
+      isDefault: true,
+    },
+    {
+      id: "claude-opus-4.1",
+      label: "Opus 4.1",
+      description: "Legacy: Opus 4.1 · reaches usage limits faster",
+    },
+    {
+      id: "claude-haiku-4.5",
+      label: "Haiku 4.5",
+      description: "Fastest model for simple tasks (released Oct 15, 2025)",
+    },
+  ],
+  "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 {