@akiojin/gwt 4.9.0 → 4.9.1

package/src/index.ts

@@ -39,8 +39,8 @@ import {
   waitForUserAcknowledgement,
 } from "./utils/terminal.js";
 import { createLogger } from "./logging/logger.js";
-import { getToolById, getSharedEnvironment } from "./config/tools.js";
-import { launchCustomAITool } from "./launcher.js";
+import { getCodingAgentById, getSharedEnvironment } from "./config/tools.js";
+import { launchCodingAgent } from "./launcher.js";
 import { saveSession, loadSession } from "./config/index.js";
 import {
   findLatestCodexSession,
@@ -543,24 +543,24 @@ export async function handleAIToolWorkflow(
       );
     }
 
-    // Get tool definition and shared environment overrides
-    const [toolConfig, sharedEnv] = await Promise.all([
-      getToolById(tool),
+    // Get coding agent definition and shared environment overrides
+    const [agentConfig, sharedEnv] = await Promise.all([
+      getCodingAgentById(tool),
       getSharedEnvironment(),
     ]);
 
-    if (!toolConfig) {
-      throw new Error(`Tool not found: ${tool}`);
+    if (!agentConfig) {
+      throw new Error(`Coding agent not found: ${tool}`);
     }
 
-    // Save selection immediately (including history) so "last tool" is reflected
-    // even if the tool is interrupted or killed mid-run (e.g., Ctrl+C).
-    // FR-042: Record timestamp to session history immediately on tool start.
+    // Save selection immediately (including history) so "last agent" is reflected
+    // even if the agent is interrupted or killed mid-run (e.g., Ctrl+C).
+    // FR-042: Record timestamp to session history immediately on agent start.
     await saveSession({
       lastWorktreePath: worktreePath,
       lastBranch: branch,
       lastUsedTool: tool,
-      toolLabel: toolConfig.displayName ?? tool,
+      toolLabel: agentConfig.displayName ?? tool,
       mode,
       model: normalizedModel ?? null,
       reasoningLevel: inferenceLevel ?? null,
@@ -607,7 +607,7 @@ export async function handleAIToolWorkflow(
             lastWorktreePath: worktreePath,
             lastBranch: branch,
             lastUsedTool: tool,
-            toolLabel: toolConfig.displayName ?? tool,
+            toolLabel: agentConfig.displayName ?? tool,
             mode,
             model: normalizedModel ?? null,
             reasoningLevel: inferenceLevel ?? null,
@@ -622,9 +622,9 @@ export async function handleAIToolWorkflow(
       }
     }, SESSION_UPDATE_INTERVAL_MS);
 
-    // Launch selected AI tool
-    // Builtin tools use their dedicated launch functions
-    // Custom tools use the generic launchCustomAITool function
+    // Launch selected coding agent
+    // Builtin agents use their dedicated launch functions
+    // Custom agents use the generic launchCodingAgent function
     let launchResult: { sessionId?: string | null } | void;
     try {
       if (tool === "claude-code") {
@@ -701,9 +701,9 @@ export async function handleAIToolWorkflow(
         }
         launchResult = await launchGeminiCLI(worktreePath, launchOptions);
       } else {
-        // Custom tool
-        printInfo(`Launching custom tool: ${toolConfig.displayName}`);
-        launchResult = await launchCustomAITool(toolConfig, {
+        // Custom coding agent
+        printInfo(`Launching custom agent: ${agentConfig.displayName}`);
+        launchResult = await launchCodingAgent(agentConfig, {
           mode:
             mode === "resume"
               ? "resume"
@@ -786,7 +786,7 @@ export async function handleAIToolWorkflow(
       lastWorktreePath: worktreePath,
       lastBranch: branch,
       lastUsedTool: tool,
-      toolLabel: toolConfig.displayName ?? tool,
+      toolLabel: agentConfig.displayName ?? tool,
       mode,
       model: normalizedModel ?? null,
       reasoningLevel: inferenceLevel ?? null,

package/src/launcher.ts

@@ -1,12 +1,12 @@
 /**
- * カスタムツール起動機能
+ * コーディングエージェント起動機能
  *
- * カスタムAIツールの起動処理を管理します。
+ * コーディングエージェントの起動処理を管理します。
  * 3つの実行タイプ（path, bunx, command）をサポートします。
  */
 
 import { execa } from "execa";
-import type { CustomAITool, LaunchOptions } from "./types/tools.js";
+import type { CodingAgent, CodingAgentLaunchOptions } from "./types/tools.js";
 import { createLogger } from "./logging/logger.js";
 
 const logger = createLogger({ category: "launcher" });
@@ -63,21 +63,24 @@ export async function resolveCommand(commandName: string): Promise<string> {
  * defaultArgs + modeArgs[mode] + extraArgs の順で引数を結合します。
  * 未定義のフィールドは空配列として扱います。
  *
- * @param tool - カスタムツール定義
+ * @param agent - コーディングエージェント定義
  * @param options - 起動オプション
  * @returns 結合された引数配列
  */
-function buildArgs(tool: CustomAITool, options: LaunchOptions): string[] {
+function buildArgs(
+  agent: CodingAgent,
+  options: CodingAgentLaunchOptions,
+): string[] {
   const args: string[] = [];
 
   // 1. defaultArgs
-  if (tool.defaultArgs) {
-    args.push(...tool.defaultArgs);
+  if (agent.defaultArgs) {
+    args.push(...agent.defaultArgs);
   }
 
   // 2. modeArgs[mode]
   const mode = options.mode || "normal";
-  const modeArgs = tool.modeArgs[mode];
+  const modeArgs = agent.modeArgs[mode];
   if (modeArgs) {
     args.push(...modeArgs);
   }
@@ -88,32 +91,36 @@ function buildArgs(tool: CustomAITool, options: LaunchOptions): string[] {
   }
 
   logger.debug(
-    { toolId: tool.id, mode: options.mode ?? "normal", argsCount: args.length },
+    {
+      agentId: agent.id,
+      mode: options.mode ?? "normal",
+      argsCount: args.length,
+    },
     "Args built",
   );
   return args;
 }
 
 /**
- * カスタムAIツールを起動
+ * コーディングエージェントを起動
  *
- * ツールの実行タイプ（path/bunx/command）に応じて適切な方法で起動します。
- * stdio: "inherit" で起動するため、ツールの入出力は親プロセスに継承されます。
+ * エージェントの実行タイプ（path/bunx/command）に応じて適切な方法で起動します。
+ * stdio: "inherit" で起動するため、エージェントの入出力は親プロセスに継承されます。
  *
- * @param tool - カスタムツール定義
+ * @param agent - コーディングエージェント定義
  * @param options - 起動オプション
  * @throws 起動に失敗した場合
  */
-export async function launchCustomAITool(
-  tool: CustomAITool,
-  options: LaunchOptions = {},
+export async function launchCodingAgent(
+  agent: CodingAgent,
+  options: CodingAgentLaunchOptions = {},
 ): Promise<void> {
-  const args = buildArgs(tool, options);
+  const args = buildArgs(agent, options);
 
   const env = {
     ...process.env,
     ...(options.sharedEnv ?? {}),
-    ...(tool.env ?? {}),
+    ...(agent.env ?? {}),
   };
 
   // execa共通オプション（cwdがundefinedの場合は含めない）
@@ -125,43 +132,43 @@ export async function launchCustomAITool(
 
   logger.info(
     {
-      toolId: tool.id,
-      toolType: tool.type,
-      command: tool.command,
+      agentId: agent.id,
+      agentType: agent.type,
+      command: agent.command,
       mode: options.mode ?? "normal",
     },
-    "Launching custom AI tool",
+    "Launching coding agent",
   );
 
-  switch (tool.type) {
+  switch (agent.type) {
     case "path": {
       // 絶対パスで直接実行
-      await execa(tool.command, args, execaOptions);
-      logger.info({ toolId: tool.id }, "Custom AI tool completed (path)");
+      await execa(agent.command, args, execaOptions);
+      logger.info({ agentId: agent.id }, "Coding agent completed (path)");
       break;
     }
 
     case "bunx": {
       // bunx経由でパッケージ実行
       // bunx [package] [args...]
-      await execa("bunx", [tool.command, ...args], execaOptions);
-      logger.info({ toolId: tool.id }, "Custom AI tool completed (bunx)");
+      await execa("bunx", [agent.command, ...args], execaOptions);
+      logger.info({ agentId: agent.id }, "Coding agent completed (bunx)");
       break;
     }
 
     case "command": {
       // PATH解決 → 実行
-      const resolvedPath = await resolveCommand(tool.command);
+      const resolvedPath = await resolveCommand(agent.command);
       await execa(resolvedPath, args, execaOptions);
-      logger.info({ toolId: tool.id }, "Custom AI tool completed (command)");
+      logger.info({ agentId: agent.id }, "Coding agent completed (command)");
       break;
     }
 
     default: {
       // TypeScriptの型チェックで到達不可能だが、実行時の安全性のため
-      const exhaustiveCheck: never = tool.type;
+      const exhaustiveCheck: never = agent.type;
       throw new Error(
-        `Unknown tool execution type: ${exhaustiveCheck as string}`,
+        `Unknown agent execution type: ${exhaustiveCheck as string}`,
       );
     }
   }

package/src/services/{customToolResolver.ts → codingAgentCommandResolver.ts}

@@ -1,10 +1,10 @@
 import { execa } from "execa";
-import type { CustomAITool, LaunchOptions } from "../types/tools.js";
+import type { CodingAgent, CodingAgentLaunchOptions } from "../types/tools.js";
 import { createLogger } from "../logging/logger.js";
 
-const logger = createLogger({ category: "custom-resolver" });
+const logger = createLogger({ category: "agent-resolver" });
 
-export interface CustomToolExecutionPlan {
+export interface CodingAgentExecutionPlan {
   command: string;
   args: string[];
   env?: NodeJS.ProcessEnv;
@@ -35,24 +35,24 @@ export async function resolveCommandPath(commandName: string): Promise<string> {
   }
 }
 
-export function buildCustomToolArgs(
-  tool: CustomAITool,
-  options: LaunchOptions = {},
+export function buildCodingAgentArgs(
+  agent: CodingAgent,
+  options: CodingAgentLaunchOptions = {},
 ): string[] {
   const args: string[] = [];
 
-  if (tool.defaultArgs?.length) {
-    args.push(...tool.defaultArgs);
+  if (agent.defaultArgs?.length) {
+    args.push(...agent.defaultArgs);
   }
 
   const mode = options.mode ?? "normal";
-  const modeArgs = tool.modeArgs?.[mode];
+  const modeArgs = agent.modeArgs?.[mode];
   if (modeArgs?.length) {
     args.push(...modeArgs);
   }
 
-  if (options.skipPermissions && tool.permissionSkipArgs?.length) {
-    args.push(...tool.permissionSkipArgs);
+  if (options.skipPermissions && agent.permissionSkipArgs?.length) {
+    args.push(...agent.permissionSkipArgs);
   }
 
   if (options.extraArgs?.length) {
@@ -60,49 +60,54 @@ export function buildCustomToolArgs(
   }
 
   logger.debug(
-    { toolId: tool.id, argsCount: args.length },
-    "Custom tool args built",
+    { agentId: agent.id, argsCount: args.length },
+    "Coding agent args built",
   );
   return args;
 }
 
-export async function prepareCustomToolExecution(
-  tool: CustomAITool,
-  options: LaunchOptions = {},
-): Promise<CustomToolExecutionPlan> {
-  const baseArgs = buildCustomToolArgs(tool, options);
-  const envOverrides: NodeJS.ProcessEnv | undefined = tool.env
-    ? ({ ...tool.env } as NodeJS.ProcessEnv)
+export async function prepareCodingAgentExecution(
+  agent: CodingAgent,
+  options: CodingAgentLaunchOptions = {},
+): Promise<CodingAgentExecutionPlan> {
+  const baseArgs = buildCodingAgentArgs(agent, options);
+  const envOverrides: NodeJS.ProcessEnv | undefined = agent.env
+    ? ({ ...agent.env } as NodeJS.ProcessEnv)
     : undefined;
 
   let command: string;
   let args: string[];
 
-  switch (tool.type) {
+  switch (agent.type) {
     case "path": {
-      command = tool.command;
+      command = agent.command;
       args = baseArgs;
       break;
     }
     case "bunx": {
       command = "bunx";
-      args = [tool.command, ...baseArgs];
+      args = [agent.command, ...baseArgs];
       break;
     }
     case "command": {
-      command = await resolveCommandPath(tool.command);
+      command = await resolveCommandPath(agent.command);
       args = baseArgs;
       break;
     }
     default: {
-      const exhaustive: never = tool.type;
-      throw new Error(`Unknown custom tool type: ${exhaustive as string}`);
+      const exhaustive: never = agent.type;
+      throw new Error(`Unknown coding agent type: ${exhaustive as string}`);
     }
   }
 
   logger.debug(
-    { toolId: tool.id, toolType: tool.type, command, hasEnv: !!envOverrides },
-    "Custom tool execution prepared",
+    {
+      agentId: agent.id,
+      agentType: agent.type,
+      command,
+      hasEnv: !!envOverrides,
+    },
+    "Coding agent execution prepared",
   );
 
   return {

package/src/services/{aiToolResolver.ts → codingAgentResolver.ts}

@@ -1,13 +1,13 @@
 import { execa } from "execa";
 import { platform } from "os";
-import { getToolById } from "../config/tools.js";
-import { CLAUDE_CODE_TOOL } from "../config/builtin-tools.js";
+import { getCodingAgentById } from "../config/tools.js";
+import { CLAUDE_CODE_TOOL } from "../config/builtin-coding-agents.js";
 import {
   CODEX_DEFAULT_ARGS,
   CLAUDE_PERMISSION_SKIP_ARGS,
-} from "../shared/aiToolConstants.js";
-import { prepareCustomToolExecution } from "./customToolResolver.js";
-import type { LaunchOptions } from "../types/tools.js";
+} from "../shared/codingAgentConstants.js";
+import { prepareCodingAgentExecution } from "./codingAgentCommandResolver.js";
+import type { CodingAgentLaunchOptions } from "../types/tools.js";
 import { createLogger } from "../logging/logger.js";
 
 const logger = createLogger({ category: "resolver" });
@@ -31,14 +31,14 @@ export interface ResolvedCommand {
   env?: NodeJS.ProcessEnv;
 }
 
-export class AIToolResolutionError extends Error {
+export class CodingAgentResolutionError extends Error {
   constructor(
     public code: ResolverErrorCode,
     message: string,
     public hints?: string[],
   ) {
     super(message);
-    this.name = "AIToolResolutionError";
+    this.name = "CodingAgentResolutionError";
   }
 }
 
@@ -78,7 +78,7 @@ async function ensureBunxAvailable(): Promise<void> {
     bunxCheckPromise = (async () => {
       const bunxExists = await commandExists("bunx");
       if (!bunxExists) {
-        throw new AIToolResolutionError(
+        throw new CodingAgentResolutionError(
           "BUNX_NOT_FOUND",
           "bunx command not found. Install Bun 1.0+ so bunx is available on PATH.",
           [
@@ -94,7 +94,7 @@ async function ensureBunxAvailable(): Promise<void> {
         logger.debug({ bunVersion: version }, "Bun version detected");
         const major = parseInt(version.split(".")[0] ?? "0", 10);
         if (!Number.isFinite(major) || major < MIN_BUN_MAJOR) {
-          throw new AIToolResolutionError(
+          throw new CodingAgentResolutionError(
             "BUN_TOO_OLD",
             `Detected Bun ${version}. Bun ${MIN_BUN_MAJOR}.0+ is required for bunx fallback execution.`,
             [
@@ -104,12 +104,12 @@ async function ensureBunxAvailable(): Promise<void> {
           );
         }
       } catch (error: unknown) {
-        if (error instanceof AIToolResolutionError) {
+        if (error instanceof CodingAgentResolutionError) {
           throw error;
         }
         const err = error as NodeJS.ErrnoException;
         if (err?.code === "ENOENT") {
-          throw new AIToolResolutionError(
+          throw new CodingAgentResolutionError(
             "BUNX_NOT_FOUND",
             "bun command not found while verifying bunx. Install Bun 1.0+ and ensure it is on PATH.",
             [
@@ -118,7 +118,7 @@ async function ensureBunxAvailable(): Promise<void> {
             ],
           );
         }
-        throw new AIToolResolutionError(
+        throw new CodingAgentResolutionError(
           "BUN_TOO_OLD",
           `Failed to verify Bun version: ${err?.message ?? "unknown error"}`,
         );
@@ -274,37 +274,37 @@ export async function resolveCodexCommand(
   };
 }
 
-export interface CustomToolCommandOptions extends LaunchOptions {
-  toolId: string;
+export interface CodingAgentCommandOptions extends CodingAgentLaunchOptions {
+  agentId: string;
 }
 
-export async function resolveCustomToolCommand(
-  options: CustomToolCommandOptions,
+export async function resolveCodingAgentCommand(
+  options: CodingAgentCommandOptions,
 ): Promise<ResolvedCommand> {
-  const tool = await getToolById(options.toolId);
-  if (!tool) {
-    logger.error({ toolId: options.toolId }, "Custom tool not found");
-    throw new AIToolResolutionError(
+  const agent = await getCodingAgentById(options.agentId);
+  if (!agent) {
+    logger.error({ agentId: options.agentId }, "Coding agent not found");
+    throw new CodingAgentResolutionError(
       "CUSTOM_TOOL_NOT_FOUND",
-      `Custom tool not found: ${options.toolId}`,
+      `Coding agent not found: ${options.agentId}`,
       [
         "Update ~/.gwt/tools.json to include this ID",
-        "Reload the Web UI after editing the tools list",
+        "Reload the Web UI after editing the agents list",
       ],
     );
   }
 
-  const execution = await prepareCustomToolExecution(tool, options);
+  const execution = await prepareCodingAgentExecution(agent, options);
 
   logger.info(
-    { toolId: options.toolId, command: execution.command },
-    "Custom tool command resolved",
+    { agentId: options.agentId, command: execution.command },
+    "Coding agent command resolved",
   );
 
   return {
     command: execution.command,
     args: execution.args,
-    usesFallback: tool.type === "bunx",
+    usesFallback: agent.type === "bunx",
     ...(execution.env ? { env: execution.env } : {}),
   };
 }
@@ -314,7 +314,7 @@ export async function isClaudeCodeAvailable(): Promise<boolean> {
     await resolveClaudeCommand();
     return true;
   } catch (error) {
-    if (error instanceof AIToolResolutionError) {
+    if (error instanceof CodingAgentResolutionError) {
       return false;
     }
     return false;
@@ -326,7 +326,7 @@ export async function isCodexAvailable(): Promise<boolean> {
     await resolveCodexCommand();
     return true;
   } catch (error) {
-    if (error instanceof AIToolResolutionError) {
+    if (error instanceof CodingAgentResolutionError) {
       return false;
     }
     return false;

package/src/shared/{aiToolConstants.ts → codingAgentConstants.ts}

@@ -1,5 +1,5 @@
 /**
- * Shared constants for AI tool integrations.
+ * Shared constants for Coding Agent integrations.
  *
  * These values are consumed by both the CLI (Node) runtime and the Web UI so
  * that command previews, permission flags, and default arguments stay in sync.

package/src/types/api.ts

@@ -51,12 +51,12 @@ export interface Worktree {
 }
 
 /**
- * AIToolSession - AI Tool実行セッション
+ * CodingAgentSession - Coding Agent実行セッション
  */
-export interface AIToolSession {
+export interface CodingAgentSession {
   sessionId: string; // UUID v4
-  toolType: "claude-code" | "codex-cli" | "custom";
-  toolName?: string | null;
+  agentType: "claude-code" | "codex-cli" | "custom";
+  agentName?: string | null;
   mode: "normal" | "continue" | "resume";
   worktreePath: string;
   ptyPid?: number | null;
@@ -69,7 +69,7 @@ export interface AIToolSession {
 }
 
 /**
- * CustomAITool - カスタムAI Tool設定
+ * CodingAgent - カスタム Coding Agent 設定
  */
 export interface EnvironmentVariable {
   key: string;
@@ -85,7 +85,7 @@ export interface EnvironmentHistoryEntry {
   source: "ui" | "os" | "cli";
 }
 
-export interface CustomAITool {
+export interface ApiCodingAgent {
   id: string; // UUID v4 or slug
   displayName: string;
   icon?: string | null;
@@ -144,14 +144,14 @@ export type BranchResponse = SuccessResponse<Branch>;
 export type BranchSyncResponse = SuccessResponse<BranchSyncResult>;
 export type WorktreeListResponse = SuccessResponse<Worktree[]>;
 export type WorktreeResponse = SuccessResponse<Worktree>;
-export type SessionListResponse = SuccessResponse<AIToolSession[]>;
-export type SessionResponse = SuccessResponse<AIToolSession>;
+export type SessionListResponse = SuccessResponse<CodingAgentSession[]>;
+export type SessionResponse = SuccessResponse<CodingAgentSession>;
 export interface ConfigPayload {
   version: string;
   updatedAt?: string | null;
   env?: EnvironmentVariable[] | null;
   history?: EnvironmentHistoryEntry[] | null;
-  tools: CustomAITool[];
+  codingAgents: ApiCodingAgent[];
 }
 
 export type ConfigResponse = SuccessResponse<ConfigPayload>;
@@ -169,14 +169,14 @@ export interface BranchSyncRequest {
 }
 
 export interface StartSessionRequest {
-  toolType: "claude-code" | "codex-cli" | "custom";
-  toolName?: string | null;
+  agentType: "claude-code" | "codex-cli" | "custom";
+  agentName?: string | null;
   mode: "normal" | "continue" | "resume";
   worktreePath: string;
   skipPermissions?: boolean;
   bypassApprovals?: boolean;
   extraArgs?: string[];
-  customToolId?: string | null;
+  customAgentId?: string | null;
 }
 
 export type UpdateConfigRequest = ConfigPayload;