@akiojin/gwt 4.9.0 → 4.9.1

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

@@ -0,0 +1,159 @@
+import React, { useState, useEffect } from "react";
+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 { getAllCodingAgents } from "../../../../config/tools.js";
+import type { CodingAgentConfig } from "../../../../types/tools.js";
+import type { CodingAgentId } from "../../types.js";
+
+/**
+ * Renderable item for the coding agent selector list.
+ */
+export interface CodingAgentItem {
+  label: string;
+  value: CodingAgentId;
+  description: string;
+}
+
+/**
+ * Props for `CodingAgentSelectorScreen`.
+ */
+export interface CodingAgentSelectorScreenProps {
+  onBack: () => void;
+  onSelect: (agentId: CodingAgentId) => void;
+  version?: string | null;
+  initialAgentId?: CodingAgentId | null;
+}
+
+/**
+ * CodingAgentSelectorScreen - Screen for selecting coding agent (Claude Code, Codex CLI, or custom agents)
+ * Layout: Header + Agent Selection + Footer
+ *
+ * This screen dynamically loads available agents from the configuration (builtin + custom).
+ */
+export function CodingAgentSelectorScreen({
+  onBack,
+  onSelect,
+  version,
+  initialAgentId,
+}: CodingAgentSelectorScreenProps) {
+  const { rows } = useTerminalSize();
+  const [agentItems, setAgentItems] = useState<CodingAgentItem[]>([]);
+  const [isLoading, setIsLoading] = useState(true);
+  const [selectedIndex, setSelectedIndex] = useState<number>(0);
+
+  // Load agents from getAllCodingAgents()
+  useEffect(() => {
+    const loadAgents = async () => {
+      try {
+        const agents = await getAllCodingAgents();
+
+        // Convert CodingAgentConfig[] to CodingAgentItem[]
+        const items: CodingAgentItem[] = agents.map(
+          (agent: CodingAgentConfig) => {
+            // Generate description based on whether it's builtin or custom
+            const description = agent.isBuiltin
+              ? `Official ${agent.displayName} agent`
+              : `Custom coding agent`;
+
+            // Add icon to label if present
+            const label = agent.icon
+              ? `${agent.icon} ${agent.displayName}`
+              : agent.displayName;
+
+            return {
+              label,
+              value: agent.id,
+              description,
+            };
+          },
+        );
+
+        setAgentItems(items);
+
+        // Decide initial cursor position based on last used agent
+        const idx =
+          initialAgentId && items.length > 0
+            ? items.findIndex((item) => item.value === initialAgentId)
+            : 0;
+        setSelectedIndex(idx >= 0 ? idx : 0);
+      } catch (error) {
+        // If loading fails, show error in console but don't crash
+        console.error("Failed to load coding agents:", error);
+        // Fall back to empty array
+        setAgentItems([]);
+      } finally {
+        setIsLoading(false);
+      }
+    };
+
+    loadAgents();
+  }, [initialAgentId]);
+
+  // Update selection when props or items change
+  useEffect(() => {
+    if (isLoading || agentItems.length === 0) return;
+    const idx =
+      initialAgentId && agentItems.length > 0
+        ? agentItems.findIndex((item) => item.value === initialAgentId)
+        : 0;
+    setSelectedIndex(idx >= 0 ? idx : 0);
+  }, [initialAgentId, agentItems, isLoading]);
+
+  // Handle keyboard input
+  // Note: Select component handles Enter and arrow keys
+  useAppInput((input, key) => {
+    if (key.escape) {
+      onBack();
+    }
+  });
+
+  // Handle agent selection
+  const handleSelect = (item: CodingAgentItem) => {
+    onSelect(item.value);
+  };
+
+  // Footer actions
+  const footerActions = [
+    { key: "enter", description: "Select" },
+    { key: "esc", description: "Back" },
+  ];
+
+  return (
+    <Box flexDirection="column" height={rows}>
+      {/* Header */}
+      <Header
+        title="Coding Agent Selection"
+        titleColor="blue"
+        version={version}
+      />
+
+      {/* Content */}
+      <Box flexDirection="column" flexGrow={1} marginTop={1}>
+        <Box marginBottom={1}>
+          <Text>Select coding agent to use:</Text>
+        </Box>
+        {isLoading ? (
+          <Text>Loading coding agents...</Text>
+        ) : agentItems.length === 0 ? (
+          <Text color="yellow">
+            No coding agents available. Please check your configuration.
+          </Text>
+        ) : (
+          <Select
+            items={agentItems}
+            onSelect={handleSelect}
+            selectedIndex={selectedIndex}
+            onSelectedIndexChange={setSelectedIndex}
+          />
+        )}
+      </Box>
+
+      {/* Footer */}
+      <Footer actions={footerActions} />
+    </Box>
+  );
+}

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

@@ -5,7 +5,11 @@ 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 type {
+  CodingAgentId,
+  InferenceLevel,
+  ModelOption,
+} from "../../types.js";
 import {
   getDefaultInferenceForModel,
   getDefaultModelOption,
@@ -33,7 +37,7 @@ interface InferenceSelectItem extends SelectItem {
  * Props for `ModelSelectorScreen`.
  */
 export interface ModelSelectorScreenProps {
-  tool: AITool;
+  tool: CodingAgentId;
   onBack: () => void;
   onSelect: (selection: ModelSelectionResult) => void;
   version?: string | null;

package/src/cli/ui/types.ts

@@ -9,7 +9,7 @@ export interface WorktreeInfo {
   hasUncommittedChanges?: boolean;
 }
 
-export type AITool = string;
+export type CodingAgentId = string;
 export type InferenceLevel = "low" | "medium" | "high" | "xhigh";
 
 /**
@@ -194,7 +194,7 @@ export type ScreenType =
   | "branch-creator"
   | "branch-action-selector"
   | "branch-quick-start"
-  | "ai-tool-selector"
+  | "coding-agent-selector"
   | "model-selector"
   | "session-selector"
   | "execution-mode-selector"

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

@@ -1,4 +1,4 @@
-import type { AITool, InferenceLevel, ModelOption } from "../types.js";
+import type { CodingAgentId, InferenceLevel, ModelOption } from "../types.js";
 
 const CODEX_BASE_LEVELS: InferenceLevel[] = ["high", "medium", "low"];
 const CODEX_MAX_LEVELS: InferenceLevel[] = ["xhigh", "high", "medium", "low"];
@@ -105,11 +105,13 @@ const MODEL_OPTIONS: Record<string, ModelOption[]> = {
   ],
 };
 
-export function getModelOptions(tool: AITool): ModelOption[] {
+export function getModelOptions(tool: CodingAgentId): ModelOption[] {
   return MODEL_OPTIONS[tool] ?? [];
 }
 
-export function getDefaultModelOption(tool: AITool): ModelOption | undefined {
+export function getDefaultModelOption(
+  tool: CodingAgentId,
+): ModelOption | undefined {
   const options = getModelOptions(tool);
   return options.find((opt) => opt.isDefault) ?? options[0];
 }
@@ -136,7 +138,7 @@ export function getDefaultInferenceForModel(
  * Normalize a model identifier for consistent display and persistence.
  */
 export function normalizeModelId(
-  tool: AITool,
+  tool: CodingAgentId,
   model?: string | null,
 ): string | null {
   if (model === null || model === undefined) return model ?? null;

package/src/config/{builtin-tools.ts → builtin-coding-agents.ts}

@@ -1,19 +1,19 @@
 /**
- * ビルトインAIツール定義
+ * ビルトインコーディングエージェント定義
  *
- * Claude Code、Codex、Gemini の CustomAITool 形式定義
+ * Claude Code、Codex、Gemini の CodingAgent 形式定義
  */
 
-import type { CustomAITool } from "../types/tools.js";
+import type { CodingAgent } from "../types/tools.js";
 import {
   CLAUDE_PERMISSION_SKIP_ARGS,
   CODEX_DEFAULT_ARGS,
-} from "../shared/aiToolConstants.js";
+} from "../shared/codingAgentConstants.js";
 
 /**
  * Claude Code のビルトイン定義
  */
-export const CLAUDE_CODE_TOOL: CustomAITool = {
+export const CLAUDE_CODE_TOOL: CodingAgent = {
   id: "claude-code",
   displayName: "Claude Code",
   type: "bunx",
@@ -32,7 +32,7 @@ export const CLAUDE_CODE_TOOL: CustomAITool = {
 /**
  * Codex のビルトイン定義
  */
-export const CODEX_CLI_TOOL: CustomAITool = {
+export const CODEX_CLI_TOOL: CodingAgent = {
   id: "codex-cli",
   displayName: "Codex",
   type: "bunx",
@@ -48,7 +48,7 @@ export const CODEX_CLI_TOOL: CustomAITool = {
 /**
  * Gemini のビルトイン定義
  */
-export const GEMINI_CLI_TOOL: CustomAITool = {
+export const GEMINI_CLI_TOOL: CodingAgent = {
   id: "gemini-cli",
   displayName: "Gemini",
   type: "bunx",
@@ -62,9 +62,9 @@ export const GEMINI_CLI_TOOL: CustomAITool = {
 };
 
 /**
- * すべてのビルトインツール
+ * すべてのビルトインコーディングエージェント
  */
-export const BUILTIN_TOOLS: CustomAITool[] = [
+export const BUILTIN_CODING_AGENTS: CodingAgent[] = [
   CLAUDE_CODE_TOOL,
   CODEX_CLI_TOOL,
   GEMINI_CLI_TOOL,

package/src/config/tools.ts

@@ -1,26 +1,26 @@
 /**
- * カスタムツール設定管理
+ * コーディングエージェント設定管理
  *
  * ~/.gwt/tools.jsonから設定を読み込み、
- * ビルトインツールと統合して管理します。
+ * ビルトインエージェントと統合して管理します。
  */
 
 import { homedir } from "node:os";
 import path from "node:path";
 import { readFile, writeFile, mkdir, rename } from "node:fs/promises";
 import type {
-  ToolsConfig,
-  CustomAITool,
-  AIToolConfig,
+  CodingAgentsConfig,
+  CodingAgent,
+  CodingAgentConfig,
 } from "../types/tools.js";
-import { BUILTIN_TOOLS } from "./builtin-tools.js";
+import { BUILTIN_CODING_AGENTS } from "./builtin-coding-agents.js";
 import { createLogger } from "../logging/logger.js";
 import { resolveProfileEnv } from "./profiles.js";
 
 const logger = createLogger({ category: "config" });
 
 /**
- * ツール設定ファイルのパス
+ * コーディングエージェント設定ファイルのパス
  * 環境変数 GWT_HOME が設定されている場合はそれを使用、それ以外はホームディレクトリ
  */
 export const WORKTREE_HOME =
@@ -32,32 +32,35 @@ export const CONFIG_DIR = path.join(WORKTREE_HOME, ".gwt");
 export const TOOLS_CONFIG_PATH = path.join(CONFIG_DIR, "tools.json");
 const TEMP_CONFIG_PATH = `${TOOLS_CONFIG_PATH}.tmp`;
 
-const DEFAULT_CONFIG: ToolsConfig = {
+const DEFAULT_CONFIG: CodingAgentsConfig = {
   version: "1.0.0",
   env: {},
-  customTools: [],
+  customCodingAgents: [],
 };
 
 /**
- * ツール設定を読み込む
+ * コーディングエージェント設定を読み込む
  *
  * ~/.gwt/tools.jsonから設定を読み込みます。
  * ファイルが存在しない場合は空配列を返します。
  *
- * @returns ToolsConfig
+ * @returns CodingAgentsConfig
  * @throws JSON構文エラー時
  */
-export async function loadToolsConfig(): Promise<ToolsConfig> {
+export async function loadCodingAgentsConfig(): Promise<CodingAgentsConfig> {
   try {
     const content = await readFile(TOOLS_CONFIG_PATH, "utf-8");
-    const config = JSON.parse(content) as ToolsConfig;
+    const config = JSON.parse(content) as CodingAgentsConfig;
 
     // 検証
-    validateToolsConfig(config);
+    validateCodingAgentsConfig(config);
 
     logger.debug(
-      { path: TOOLS_CONFIG_PATH, toolCount: config.customTools.length },
-      "Tools config loaded",
+      {
+        path: TOOLS_CONFIG_PATH,
+        agentCount: config.customCodingAgents.length,
+      },
+      "Coding agents config loaded",
     );
 
     return {
@@ -69,7 +72,7 @@ export async function loadToolsConfig(): Promise<ToolsConfig> {
     if (error instanceof Error && "code" in error && error.code === "ENOENT") {
       logger.debug(
         { path: TOOLS_CONFIG_PATH },
-        "Tools config not found, using defaults",
+        "Coding agents config not found, using defaults",
       );
       return { ...DEFAULT_CONFIG };
     }
@@ -78,7 +81,7 @@ export async function loadToolsConfig(): Promise<ToolsConfig> {
     if (error instanceof SyntaxError) {
       logger.error(
         { path: TOOLS_CONFIG_PATH, error: error.message },
-        "Tools config parse error",
+        "Coding agents config parse error",
       );
       throw new Error(
         `Failed to parse tools.json: ${error.message}\n` +
@@ -92,20 +95,20 @@ export async function loadToolsConfig(): Promise<ToolsConfig> {
 }
 
 /**
- * ToolsConfig全体を検証
+ * CodingAgentsConfig全体を検証
  *
  * @param config - 検証対象の設定
  * @throws 検証エラー時
  */
-function validateToolsConfig(config: ToolsConfig): void {
+function validateCodingAgentsConfig(config: CodingAgentsConfig): void {
   // versionフィールドの検証
   if (!config.version || typeof config.version !== "string") {
     throw new Error("version field is required and must be a string");
   }
 
-  // customToolsフィールドの検証
-  if (!Array.isArray(config.customTools)) {
-    throw new Error("customTools field must be an array");
+  // customCodingAgentsフィールドの検証
+  if (!Array.isArray(config.customCodingAgents)) {
+    throw new Error("customCodingAgents field must be an array");
   }
 
   if (config.env && typeof config.env !== "object") {
@@ -123,40 +126,42 @@ function validateToolsConfig(config: ToolsConfig): void {
     }
   }
 
-  // 各ツールの検証
+  // 各エージェントの検証
   const seenIds = new Set<string>();
-  for (const tool of config.customTools) {
-    validateCustomAITool(tool);
+  for (const agent of config.customCodingAgents) {
+    validateCodingAgent(agent);
 
     // ID重複チェック
-    if (seenIds.has(tool.id)) {
+    if (seenIds.has(agent.id)) {
       throw new Error(
-        `Duplicate tool ID found: "${tool.id}"\n` +
-          `Each tool must have a unique ID in ${TOOLS_CONFIG_PATH}`,
+        `Duplicate agent ID found: "${agent.id}"\n` +
+          `Each agent must have a unique ID in ${TOOLS_CONFIG_PATH}`,
       );
     }
-    seenIds.add(tool.id);
+    seenIds.add(agent.id);
 
-    // ビルトインツールとのID重複チェック
-    const builtinIds = BUILTIN_TOOLS.map((t) => t.id);
-    if (builtinIds.includes(tool.id)) {
+    // ビルトインエージェントとのID重複チェック
+    const builtinIds = BUILTIN_CODING_AGENTS.map((t) => t.id);
+    if (builtinIds.includes(agent.id)) {
       throw new Error(
-        `Tool ID "${tool.id}" conflicts with builtin tool\n` +
-          `Builtin tool IDs: ${builtinIds.join(", ")}`,
+        `Agent ID "${agent.id}" conflicts with builtin agent\n` +
+          `Builtin agent IDs: ${builtinIds.join(", ")}`,
       );
     }
   }
 }
 
-export async function saveToolsConfig(config: ToolsConfig): Promise<void> {
-  const normalized: ToolsConfig = {
+export async function saveCodingAgentsConfig(
+  config: CodingAgentsConfig,
+): Promise<void> {
+  const normalized: CodingAgentsConfig = {
     version: config.version,
     updatedAt: config.updatedAt ?? new Date().toISOString(),
     env: config.env ?? {},
-    customTools: config.customTools,
+    customCodingAgents: config.customCodingAgents,
   };
 
-  validateToolsConfig(normalized);
+  validateCodingAgentsConfig(normalized);
 
   await mkdir(CONFIG_DIR, { recursive: true });
   const payload = JSON.stringify(normalized, null, 2);
@@ -167,7 +172,7 @@ export async function saveToolsConfig(config: ToolsConfig): Promise<void> {
 /**
  * 共有環境変数を取得
  *
- * AIツール起動時に適用される環境変数を返します。
+ * コーディングエージェント起動時に適用される環境変数を返します。
  * マージ優先順位（後勝ち）:
  * 1. tools.json の env フィールド
  * 2. profiles.yaml のアクティブプロファイル
@@ -176,7 +181,7 @@ export async function saveToolsConfig(config: ToolsConfig): Promise<void> {
  */
 export async function getSharedEnvironment(): Promise<Record<string, string>> {
   const [config, profileEnv] = await Promise.all([
-    loadToolsConfig(),
+    loadCodingAgentsConfig(),
     resolveProfileEnv(),
   ]);
 
@@ -187,104 +192,111 @@ export async function getSharedEnvironment(): Promise<Record<string, string>> {
 }
 
 /**
- * CustomAITool単体を検証
+ * CodingAgent単体を検証
  *
- * @param tool - 検証対象のツール
+ * @param agent - 検証対象のエージェント
  * @throws 検証エラー時
  */
-function validateCustomAITool(tool: unknown): asserts tool is CustomAITool {
+function validateCodingAgent(agent: unknown): asserts agent is CodingAgent {
   // eslint-disable-next-line @typescript-eslint/no-explicit-any
-  const t = tool as any;
+  const a = agent as any;
 
   // 必須フィールドの存在チェック
   const requiredFields = ["id", "displayName", "type", "command", "modeArgs"];
   for (const field of requiredFields) {
-    if (!t[field]) {
+    if (!a[field]) {
       throw new Error(
-        `Required field "${field}" is missing in tool configuration`,
+        `Required field "${field}" is missing in agent configuration`,
       );
     }
   }
 
   // id形式の検証（小文字英数字とハイフンのみ）
-  if (!/^[a-z0-9-]+$/.test(t.id)) {
+  if (!/^[a-z0-9-]+$/.test(a.id)) {
     throw new Error(
-      `Invalid tool ID format: "${t.id}"\n` +
-        `Tool ID must contain only lowercase letters, numbers, and hyphens (pattern: ^[a-z0-9-]+$)`,
+      `Invalid agent ID format: "${a.id}"\n` +
+        `Agent ID must contain only lowercase letters, numbers, and hyphens (pattern: ^[a-z0-9-]+$)`,
     );
   }
 
   // typeフィールドの値検証
   const validTypes = ["path", "bunx", "command"];
-  if (!validTypes.includes(t.type)) {
+  if (!validTypes.includes(a.type)) {
     throw new Error(
-      `Invalid type: "${t.type}"\n` +
+      `Invalid type: "${a.type}"\n` +
         `Type must be one of: ${validTypes.join(", ")}`,
     );
   }
 
   // type='path'の場合、commandが絶対パスであることを確認
-  if (t.type === "path" && !path.isAbsolute(t.command)) {
+  if (a.type === "path" && !path.isAbsolute(a.command)) {
     throw new Error(
-      `For type="path", command must be an absolute path: "${t.command}"`,
+      `For type="path", command must be an absolute path: "${a.command}"`,
     );
   }
 
   // modeArgsの検証（少なくとも1つのモードが定義されている）
-  if (!t.modeArgs.normal && !t.modeArgs.continue && !t.modeArgs.resume) {
+  if (!a.modeArgs.normal && !a.modeArgs.continue && !a.modeArgs.resume) {
     throw new Error(
-      `modeArgs must define at least one mode (normal, continue, or resume) for tool "${t.id}"`,
+      `modeArgs must define at least one mode (normal, continue, or resume) for agent "${a.id}"`,
     );
   }
 }
 
 /**
- * IDでツールを検索
+ * IDでコーディングエージェントを検索
  *
- * @param id - ツールID
- * @returns ツール設定（見つからない場合はundefined）
+ * @param id - エージェントID
+ * @returns エージェント設定（見つからない場合はundefined）
  */
-export async function getToolById(
+export async function getCodingAgentById(
   id: string,
-): Promise<CustomAITool | undefined> {
-  // ビルトインツールから検索
-  const builtinTool = BUILTIN_TOOLS.find((t) => t.id === id);
-  if (builtinTool) {
-    logger.debug({ id, found: true, isBuiltin: true }, "Tool lookup");
-    return builtinTool;
+): Promise<CodingAgent | undefined> {
+  // ビルトインエージェントから検索
+  const builtinAgent = BUILTIN_CODING_AGENTS.find((a) => a.id === id);
+  if (builtinAgent) {
+    logger.debug({ id, found: true, isBuiltin: true }, "Coding agent lookup");
+    return builtinAgent;
   }
 
-  // カスタムツールから検索
-  const config = await loadToolsConfig();
-  const customTool = config.customTools.find((t) => t.id === id);
-  logger.debug({ id, found: !!customTool, isBuiltin: false }, "Tool lookup");
-  return customTool;
+  // カスタムエージェントから検索
+  const config = await loadCodingAgentsConfig();
+  const customAgent = config.customCodingAgents.find((a) => a.id === id);
+  logger.debug(
+    { id, found: !!customAgent, isBuiltin: false },
+    "Coding agent lookup",
+  );
+  return customAgent;
 }
 
 /**
- * すべてのツール（ビルトイン+カスタム）を取得
+ * すべてのコーディングエージェント（ビルトイン+カスタム）を取得
  *
- * @returns AIToolConfigの配列
+ * @returns CodingAgentConfigの配列
  */
-export async function getAllTools(): Promise<AIToolConfig[]> {
-  const config = await loadToolsConfig();
-
-  // ビルトインツールをAIToolConfig形式に変換
-  const builtinConfigs: AIToolConfig[] = BUILTIN_TOOLS.map((tool) => ({
-    id: tool.id,
-    displayName: tool.displayName,
-    ...(tool.icon ? { icon: tool.icon } : {}),
-    isBuiltin: true,
-  }));
-
-  // カスタムツールをAIToolConfig形式に変換
-  const customConfigs: AIToolConfig[] = config.customTools.map((tool) => ({
-    id: tool.id,
-    displayName: tool.displayName,
-    ...(tool.icon ? { icon: tool.icon } : {}),
-    isBuiltin: false,
-    customConfig: tool,
-  }));
+export async function getAllCodingAgents(): Promise<CodingAgentConfig[]> {
+  const config = await loadCodingAgentsConfig();
+
+  // ビルトインエージェントをCodingAgentConfig形式に変換
+  const builtinConfigs: CodingAgentConfig[] = BUILTIN_CODING_AGENTS.map(
+    (agent) => ({
+      id: agent.id,
+      displayName: agent.displayName,
+      ...(agent.icon ? { icon: agent.icon } : {}),
+      isBuiltin: true,
+    }),
+  );
+
+  // カスタムエージェントをCodingAgentConfig形式に変換
+  const customConfigs: CodingAgentConfig[] = config.customCodingAgents.map(
+    (agent) => ({
+      id: agent.id,
+      displayName: agent.displayName,
+      ...(agent.icon ? { icon: agent.icon } : {}),
+      isBuiltin: false,
+      customConfig: agent,
+    }),
+  );
 
   // ビルトイン + カスタム の順で統合
   return [...builtinConfigs, ...customConfigs];