@akiojin/gwt 4.9.1 → 4.11.6

package/src/utils/__tests__/npmRegistry.test.ts

@@ -0,0 +1,250 @@
+import { describe, expect, it, mock, beforeEach, afterEach } from "bun:test";
+
+// TDD: テストを先に書き、実装は後から行う
+
+describe("npmRegistry", () => {
+  describe("fetchPackageVersions", () => {
+    let originalFetch: typeof globalThis.fetch;
+
+    beforeEach(() => {
+      originalFetch = globalThis.fetch;
+    });
+
+    afterEach(() => {
+      globalThis.fetch = originalFetch;
+    });
+
+    it("should return latest 10 versions including prereleases", async () => {
+      // Mock npm registry response
+      globalThis.fetch = mock(async () => ({
+        ok: true,
+        json: async () => ({
+          "dist-tags": {
+            latest: "1.0.10",
+            next: "1.1.0-beta.1",
+          },
+          time: {
+            "1.0.1": "2024-01-01T00:00:00.000Z",
+            "1.0.2": "2024-01-02T00:00:00.000Z",
+            "1.0.3": "2024-01-03T00:00:00.000Z",
+            "1.0.4": "2024-01-04T00:00:00.000Z",
+            "1.0.5": "2024-01-05T00:00:00.000Z",
+            "1.0.6": "2024-01-06T00:00:00.000Z",
+            "1.0.7": "2024-01-07T00:00:00.000Z",
+            "1.0.8": "2024-01-08T00:00:00.000Z",
+            "1.0.9": "2024-01-09T00:00:00.000Z",
+            "1.0.10": "2024-01-10T00:00:00.000Z",
+            "1.1.0-alpha.1": "2024-01-11T00:00:00.000Z",
+            "1.1.0-beta.1": "2024-01-12T00:00:00.000Z",
+          },
+          versions: {
+            "1.0.1": {},
+            "1.0.2": {},
+            "1.0.3": {},
+            "1.0.4": {},
+            "1.0.5": {},
+            "1.0.6": {},
+            "1.0.7": {},
+            "1.0.8": {},
+            "1.0.9": {},
+            "1.0.10": {},
+            "1.1.0-alpha.1": {},
+            "1.1.0-beta.1": {},
+          },
+        }),
+      })) as typeof globalThis.fetch;
+
+      const { fetchPackageVersions } = await import("../npmRegistry.js");
+      const versions = await fetchPackageVersions("@anthropic-ai/claude-code");
+
+      expect(versions.length).toBe(10);
+      // Should be sorted by publish date, newest first
+      expect(versions[0].version).toBe("1.1.0-beta.1");
+      expect(versions[0].isPrerelease).toBe(true);
+      expect(versions[1].version).toBe("1.1.0-alpha.1");
+      expect(versions[1].isPrerelease).toBe(true);
+      expect(versions[2].version).toBe("1.0.10");
+      expect(versions[2].isPrerelease).toBe(false);
+    });
+
+    it("should return empty array on timeout", async () => {
+      // Mock fetch that respects AbortSignal
+      globalThis.fetch = mock(async (_url: string, options?: RequestInit) => {
+        const signal = options?.signal as AbortSignal | undefined;
+        return new Promise((resolve, reject) => {
+          const timer = setTimeout(() => {
+            resolve({ ok: true, json: async () => ({}) });
+          }, 5000);
+
+          if (signal) {
+            signal.addEventListener("abort", () => {
+              clearTimeout(timer);
+              reject(new DOMException("Aborted", "AbortError"));
+            });
+          }
+        });
+      }) as typeof globalThis.fetch;
+
+      const { fetchPackageVersions } = await import("../npmRegistry.js");
+      const versions = await fetchPackageVersions(
+        "@anthropic-ai/claude-code",
+        10,
+        100, // 100ms timeout
+      );
+
+      expect(versions).toEqual([]);
+    });
+
+    it("should return empty array on network error", async () => {
+      globalThis.fetch = mock(async () => {
+        throw new Error("Network error");
+      }) as typeof globalThis.fetch;
+
+      const { fetchPackageVersions } = await import("../npmRegistry.js");
+      const versions = await fetchPackageVersions("@anthropic-ai/claude-code");
+
+      expect(versions).toEqual([]);
+    });
+
+    it("should return empty array on non-ok response", async () => {
+      globalThis.fetch = mock(async () => ({
+        ok: false,
+        status: 404,
+      })) as typeof globalThis.fetch;
+
+      const { fetchPackageVersions } = await import("../npmRegistry.js");
+      const versions = await fetchPackageVersions("nonexistent-package");
+
+      expect(versions).toEqual([]);
+    });
+  });
+
+  describe("parsePackageCommand", () => {
+    it("should parse package name without version", async () => {
+      const { parsePackageCommand } = await import("../npmRegistry.js");
+      const result = parsePackageCommand("@anthropic-ai/claude-code");
+
+      expect(result.packageName).toBe("@anthropic-ai/claude-code");
+      expect(result.version).toBeNull();
+    });
+
+    it("should parse package name with @latest", async () => {
+      const { parsePackageCommand } = await import("../npmRegistry.js");
+      const result = parsePackageCommand("@anthropic-ai/claude-code@latest");
+
+      expect(result.packageName).toBe("@anthropic-ai/claude-code");
+      expect(result.version).toBe("latest");
+    });
+
+    it("should parse package name with specific version", async () => {
+      const { parsePackageCommand } = await import("../npmRegistry.js");
+      const result = parsePackageCommand("@anthropic-ai/claude-code@1.0.3");
+
+      expect(result.packageName).toBe("@anthropic-ai/claude-code");
+      expect(result.version).toBe("1.0.3");
+    });
+
+    it("should parse non-scoped package name", async () => {
+      const { parsePackageCommand } = await import("../npmRegistry.js");
+      const result = parsePackageCommand("opencode-ai@latest");
+
+      expect(result.packageName).toBe("opencode-ai");
+      expect(result.version).toBe("latest");
+    });
+  });
+
+  describe("resolveVersionSuffix", () => {
+    it("should return empty string for 'installed'", async () => {
+      const { resolveVersionSuffix } = await import("../npmRegistry.js");
+      expect(resolveVersionSuffix("installed")).toBe("");
+    });
+
+    it("should return empty string for undefined", async () => {
+      const { resolveVersionSuffix } = await import("../npmRegistry.js");
+      expect(resolveVersionSuffix(undefined)).toBe("");
+    });
+
+    it("should return '@latest' for 'latest'", async () => {
+      const { resolveVersionSuffix } = await import("../npmRegistry.js");
+      expect(resolveVersionSuffix("latest")).toBe("@latest");
+    });
+
+    it("should return '@X.Y.Z' for specific version", async () => {
+      const { resolveVersionSuffix } = await import("../npmRegistry.js");
+      expect(resolveVersionSuffix("1.0.3")).toBe("@1.0.3");
+    });
+
+    it("should return '@X.Y.Z-beta.1' for prerelease version", async () => {
+      const { resolveVersionSuffix } = await import("../npmRegistry.js");
+      expect(resolveVersionSuffix("1.1.0-beta.1")).toBe("@1.1.0-beta.1");
+    });
+  });
+
+  describe("parseGlobalPackagesOutput", () => {
+    it("should parse bun pm ls -g output correctly", async () => {
+      const { parseGlobalPackagesOutput } = await import("../npmRegistry.js");
+      const output = `/root/.bun/install/global node_modules (17)
+├── @anthropic-ai/claude-code@2.0.76
+└── @openai/codex@0.77.0`;
+
+      const result = parseGlobalPackagesOutput(output);
+
+      expect(result.path).toBe("/root/.bun/install/global");
+      expect(result.packages).toHaveLength(2);
+      expect(result.packages[0]).toEqual({
+        name: "@anthropic-ai/claude-code",
+        version: "2.0.76",
+      });
+      expect(result.packages[1]).toEqual({
+        name: "@openai/codex",
+        version: "0.77.0",
+      });
+    });
+
+    it("should return empty packages for empty output", async () => {
+      const { parseGlobalPackagesOutput } = await import("../npmRegistry.js");
+      const result = parseGlobalPackagesOutput("");
+
+      expect(result.path).toBeNull();
+      expect(result.packages).toHaveLength(0);
+    });
+
+    it("should parse single package output", async () => {
+      const { parseGlobalPackagesOutput } = await import("../npmRegistry.js");
+      const output = `/home/user/.bun/install/global node_modules (1)
+└── opencode-ai@1.0.0`;
+
+      const result = parseGlobalPackagesOutput(output);
+
+      expect(result.path).toBe("/home/user/.bun/install/global");
+      expect(result.packages).toHaveLength(1);
+      expect(result.packages[0]).toEqual({
+        name: "opencode-ai",
+        version: "1.0.0",
+      });
+    });
+  });
+
+  describe("getInstalledPackageInfo", () => {
+    it("should return package info when installed globally", async () => {
+      const { getInstalledPackageInfo } = await import("../npmRegistry.js");
+      // This test relies on actual global packages - may need adjustment
+      const result = await getInstalledPackageInfo("@anthropic-ai/claude-code");
+
+      // If claude-code is installed globally, it should return info
+      if (result) {
+        expect(result.version).toBeDefined();
+        expect(result.path).toBeDefined();
+      }
+    });
+
+    it("should return null when package is not installed", async () => {
+      const { getInstalledPackageInfo } = await import("../npmRegistry.js");
+      const result = await getInstalledPackageInfo(
+        "nonexistent-package-xyz-123",
+      );
+
+      expect(result).toBeNull();
+    });
+  });
+});

package/src/utils/__tests__/prompt.test.ts

@@ -1,10 +1,10 @@
 import { PassThrough } from "node:stream";
-import { describe, expect, it, vi, beforeEach } from "vitest";
+import { describe, expect, it, mock, beforeEach } from "bun:test";
 
 // Shared mock target to avoid hoisting issues
 const terminalStreams: Record<string, unknown> = {};
 
-vi.mock("../terminal.js", () => ({
+mock.module("../terminal.js", () => ({
   getTerminalStreams: () => terminalStreams,
 }));
 
@@ -17,7 +17,6 @@ const withTimeout = <T>(promise: Promise<T>, ms = 500): Promise<T> =>
   ]);
 
 const resetTerminalStreams = () => {
-  vi.resetModules();
   for (const key of Object.keys(terminalStreams)) {
     delete terminalStreams[key];
   }
@@ -27,7 +26,7 @@ const setupTerminalStreams = (isTTY: boolean) => {
   const stdin = new PassThrough() as unknown as NodeJS.ReadStream;
   const stdout = new PassThrough() as unknown as NodeJS.WriteStream;
   Object.defineProperty(stdin, "isTTY", { value: isTTY, configurable: true });
-  const exitRawMode = vi.fn();
+  const exitRawMode = mock();
   Object.assign(terminalStreams, {
     stdin,
     stdout,
@@ -82,7 +81,7 @@ describe("waitForEnter", () => {
 
 describe("confirmYesNo", () => {
   let stdin: NodeJS.ReadStream;
-  let exitRawMode: ReturnType<typeof vi.fn>;
+  let exitRawMode: ReturnType<typeof mock>;
 
   beforeEach(() => {
     resetTerminalStreams();

package/src/utils/coding-agent-colors.ts

@@ -0,0 +1,165 @@
+/**
+ * Coding Agent Color Definitions
+ *
+ * This module provides consistent color definitions for coding agents
+ * across CLI and Web UI (SPEC-3b0ed29b FR-024~FR-027).
+ */
+
+/**
+ * Tool ID constants for coding agents
+ */
+export const CODING_AGENT_TOOL_IDS = {
+  CLAUDE_CODE: "claude-code",
+  CODEX_CLI: "codex-cli",
+  GEMINI_CLI: "gemini-cli",
+  OPENCODE: "opencode",
+} as const;
+
+/**
+ * Terminal color names for CLI (OpenTUI/SolidJS)
+ */
+export type TerminalColorName =
+  | "yellow"
+  | "cyan"
+  | "magenta"
+  | "green"
+  | "gray"
+  | "white";
+
+/**
+ * Color definitions for coding agents
+ * - Terminal colors: Used in CLI UI (OpenTUI/SolidJS)
+ * - Hex colors: Used in Web UI (React/CSS)
+ */
+export const CODING_AGENT_COLORS = {
+  [CODING_AGENT_TOOL_IDS.CLAUDE_CODE]: {
+    terminal: "yellow" as TerminalColorName,
+    hex: "#f6e05e",
+    tailwind: "text-yellow-400",
+  },
+  [CODING_AGENT_TOOL_IDS.CODEX_CLI]: {
+    terminal: "cyan" as TerminalColorName,
+    hex: "#4fd1c5",
+    tailwind: "text-cyan-400",
+  },
+  [CODING_AGENT_TOOL_IDS.GEMINI_CLI]: {
+    terminal: "magenta" as TerminalColorName,
+    hex: "#d53f8c",
+    tailwind: "text-pink-500",
+  },
+  [CODING_AGENT_TOOL_IDS.OPENCODE]: {
+    terminal: "green" as TerminalColorName,
+    hex: "#48bb78",
+    tailwind: "text-green-400",
+  },
+} as const;
+
+/**
+ * Default color for unknown/custom agents
+ */
+export const DEFAULT_AGENT_COLOR = {
+  terminal: "gray" as TerminalColorName,
+  hex: "#a0aec0",
+  tailwind: "text-gray-400",
+};
+
+/**
+ * Get terminal color name for a coding agent
+ * Used in CLI UI (OpenTUI/SolidJS)
+ *
+ * @param toolId - The tool ID (e.g., "claude-code", "codex-cli")
+ * @param label - Optional label for fallback (used for unknown detection)
+ * @returns Terminal color name
+ */
+export function getAgentTerminalColor(
+  toolId?: string | null,
+  label?: string,
+): TerminalColorName {
+  if (!toolId) {
+    const trimmed = label?.trim().toLowerCase();
+    if (!trimmed || trimmed === "unknown") {
+      return "gray";
+    }
+    return "white";
+  }
+
+  const color = CODING_AGENT_COLORS[toolId as keyof typeof CODING_AGENT_COLORS];
+  return color?.terminal ?? DEFAULT_AGENT_COLOR.terminal;
+}
+
+/**
+ * Get hex color for a coding agent
+ * Used in Web UI (React/CSS)
+ *
+ * @param toolId - The tool ID (e.g., "claude-code", "codex-cli")
+ * @returns Hex color string
+ */
+export function getAgentHexColor(toolId?: string | null): string {
+  if (!toolId) {
+    return DEFAULT_AGENT_COLOR.hex;
+  }
+
+  const color = CODING_AGENT_COLORS[toolId as keyof typeof CODING_AGENT_COLORS];
+  return color?.hex ?? DEFAULT_AGENT_COLOR.hex;
+}
+
+/**
+ * Get Tailwind CSS class for a coding agent
+ * Used in Web UI (React/Tailwind)
+ *
+ * @param toolId - The tool ID (e.g., "claude-code", "codex-cli")
+ * @returns Tailwind CSS class name
+ */
+export function getAgentTailwindClass(toolId?: string | null): string {
+  if (!toolId) {
+    return DEFAULT_AGENT_COLOR.tailwind;
+  }
+
+  const color = CODING_AGENT_COLORS[toolId as keyof typeof CODING_AGENT_COLORS];
+  return color?.tailwind ?? DEFAULT_AGENT_COLOR.tailwind;
+}
+
+/**
+ * Normalize agent type string to tool ID
+ * Handles various naming conventions used across the codebase
+ *
+ * @param agentType - Agent type string (e.g., "claude", "codex-cli", "Claude Code")
+ * @returns Normalized tool ID
+ */
+export function normalizeAgentToToolId(
+  agentType?: string | null,
+): string | null {
+  if (!agentType) return null;
+
+  const normalized = agentType.toLowerCase().trim();
+
+  // Direct matches
+  if (normalized === "claude-code" || normalized === "claude") {
+    return CODING_AGENT_TOOL_IDS.CLAUDE_CODE;
+  }
+  if (normalized === "codex-cli" || normalized === "codex") {
+    return CODING_AGENT_TOOL_IDS.CODEX_CLI;
+  }
+  if (normalized === "gemini-cli" || normalized === "gemini") {
+    return CODING_AGENT_TOOL_IDS.GEMINI_CLI;
+  }
+  if (normalized === "opencode" || normalized === "open-code") {
+    return CODING_AGENT_TOOL_IDS.OPENCODE;
+  }
+
+  // Label-based matches
+  if (normalized.includes("claude")) {
+    return CODING_AGENT_TOOL_IDS.CLAUDE_CODE;
+  }
+  if (normalized.includes("codex")) {
+    return CODING_AGENT_TOOL_IDS.CODEX_CLI;
+  }
+  if (normalized.includes("gemini")) {
+    return CODING_AGENT_TOOL_IDS.GEMINI_CLI;
+  }
+  if (normalized.includes("opencode")) {
+    return CODING_AGENT_TOOL_IDS.OPENCODE;
+  }
+
+  return agentType; // Return as-is for custom agents
+}

package/src/utils/command.ts

@@ -41,6 +41,14 @@ const KNOWN_INSTALL_PATHS: Record<string, { unix: string[]; win32: string[] }> =
       ],
       win32: [join(homedir(), ".bun", "bin", "gemini.exe")],
     },
+    opencode: {
+      unix: [
+        join(homedir(), ".bun", "bin", "opencode"),
+        join(homedir(), ".local", "bin", "opencode"),
+        "/usr/local/bin/opencode",
+      ],
+      win32: [join(homedir(), ".bun", "bin", "opencode.exe")],
+    },
   };
 
 /**
@@ -50,6 +58,7 @@ const BUILTIN_TOOLS = [
   { id: "claude-code", commandName: "claude", displayName: "Claude" },
   { id: "codex-cli", commandName: "codex", displayName: "Codex" },
   { id: "gemini-cli", commandName: "gemini", displayName: "Gemini" },
+  { id: "opencode", commandName: "opencode", displayName: "OpenCode" },
 ] as const;
 
 /**
@@ -190,7 +199,7 @@ export async function findCommand(
  * If the standard lookup fails, checks known installation paths
  * as a fallback for common tools.
  *
- * @param commandName - Command name to look up (e.g. `claude`, `npx`, `gemini`)
+ * @param commandName - Command name to look up (e.g. `claude`, `gemini`)
  * @returns true if the command exists in PATH or known paths
  */
 export async function isCommandAvailable(

package/src/utils/error-utils.ts

@@ -0,0 +1,133 @@
+/**
+ * Error Utilities
+ *
+ * 統一されたエラーハンドリングユーティリティ。
+ * カスタムエラークラスの型判定と分類を提供します。
+ */
+
+import { GitError } from "../git.js";
+import { WorktreeError } from "../worktree.js";
+import { ClaudeError } from "../claude.js";
+import { CodexError } from "../codex.js";
+import { GeminiError } from "../gemini.js";
+import { DependencyInstallError } from "../services/dependency-installer.js";
+
+/**
+ * エラー名のリスト定義
+ */
+const GIT_RELATED_ERROR_NAMES = ["GitError", "WorktreeError"] as const;
+const RECOVERABLE_ERROR_NAMES = [
+  "GitError",
+  "WorktreeError",
+  "CodexError",
+  "GeminiError",
+  "DependencyInstallError",
+] as const;
+const CODING_AGENT_ERROR_NAMES = [
+  "ClaudeError",
+  "CodexError",
+  "GeminiError",
+] as const;
+
+/**
+ * 型ガード: エラー名で判定
+ */
+function getErrorName(error: unknown): string | undefined {
+  if (!error) return undefined;
+
+  if (error instanceof Error) {
+    return error.name;
+  }
+
+  if (
+    typeof error === "object" &&
+    "name" in (error as Record<string, unknown>)
+  ) {
+    return (error as { name?: string }).name;
+  }
+
+  return undefined;
+}
+
+/**
+ * 型ガード: 指定のエラークラスまたはエラー名に該当するか判定
+ */
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+type ErrorConstructor = new (...args: any[]) => Error;
+
+function isErrorOfType(
+  error: unknown,
+  constructors: ErrorConstructor[],
+  names: readonly string[],
+): boolean {
+  if (!error) return false;
+
+  // instanceof チェック
+  for (const ctor of constructors) {
+    if (error instanceof ctor) return true;
+  }
+
+  // 名前チェック（異なるモジュールからのインスタンス用）
+  const errorName = getErrorName(error);
+  if (errorName && names.includes(errorName)) {
+    return true;
+  }
+
+  return false;
+}
+
+/**
+ * Git関連エラー（GitError, WorktreeError）かどうかを判定
+ */
+export function isGitRelatedError(error: unknown): boolean {
+  return isErrorOfType(
+    error,
+    [GitError, WorktreeError],
+    GIT_RELATED_ERROR_NAMES,
+  );
+}
+
+/**
+ * 回復可能なエラー（リトライ/続行可能）かどうかを判定
+ */
+export function isRecoverableError(error: unknown): boolean {
+  return isErrorOfType(
+    error,
+    [GitError, WorktreeError, CodexError, GeminiError, DependencyInstallError],
+    RECOVERABLE_ERROR_NAMES,
+  );
+}
+
+/**
+ * コーディングエージェント関連エラー（Claude, Codex, Gemini）かどうかを判定
+ */
+export function isCodingAgentError(error: unknown): boolean {
+  return isErrorOfType(
+    error,
+    [ClaudeError, CodexError, GeminiError],
+    CODING_AGENT_ERROR_NAMES,
+  );
+}
+
+/**
+ * エラーメッセージを安全に取得
+ */
+export function getErrorMessage(error: unknown): string {
+  if (error instanceof Error) {
+    return error.message;
+  }
+  if (typeof error === "string") {
+    return error;
+  }
+  return String(error);
+}
+
+/**
+ * エラーの根本原因を取得
+ */
+export function getErrorCause(error: unknown): unknown {
+  if (error instanceof Error && "cause" in error) {
+    return error.cause;
+  }
+  return undefined;
+}