@akiojin/gwt 4.6.0 → 4.7.0

package/src/claude.ts

@@ -6,7 +6,7 @@ import {
   getTerminalStreams,
   resetTerminalModes,
 } from "./utils/terminal.js";
-import { isCommandAvailable } from "./utils/command.js";
+import { findCommand } from "./utils/command.js";
 import { findLatestClaudeSession } from "./utils/session.js";
 
 const CLAUDE_CLI_PACKAGE = "@anthropic-ai/claude-code@latest";
@@ -232,7 +232,9 @@ export async function launchClaudeCode(
     const childStdio = createChildStdio();
 
     // Auto-detect locally installed claude command
-    const hasLocalClaude = await isClaudeCommandAvailable();
+    const claudeLookup = await findCommand("claude");
+    const npxLookup =
+      process.platform === "win32" ? await findCommand("npx") : null;
 
     const execInteractive = async (
       file: string,
@@ -258,11 +260,12 @@ export async function launchClaudeCode(
     };
 
     try {
-      if (hasLocalClaude) {
+      if (claudeLookup.source === "installed" && claudeLookup.path) {
+        // Use the full path to avoid PATH issues in non-interactive shells
         console.log(
           chalk.green("   ✨ Using locally installed claude command"),
         );
-        await execInteractive("claude", args, {
+        await execInteractive(claudeLookup.path, args, {
           cwd: worktreePath,
           stdin: childStdio.stdin,
           stdout: childStdio.stdout,
@@ -270,11 +273,20 @@ export async function launchClaudeCode(
           env: launchEnv,
         });
       } else {
-        console.log(
-          chalk.cyan(
-            "   🔄 Falling back to bunx @anthropic-ai/claude-code@latest",
-          ),
-        );
+        const useNpx = npxLookup?.source === "installed" && npxLookup?.path;
+        if (useNpx) {
+          console.log(
+            chalk.cyan(
+              "   🔄 Falling back to npx @anthropic-ai/claude-code@latest",
+            ),
+          );
+        } else {
+          console.log(
+            chalk.cyan(
+              "   🔄 Falling back to bunx @anthropic-ai/claude-code@latest",
+            ),
+          );
+        }
         console.log(
           chalk.yellow(
             "   💡 Recommended: Install Claude Code via official method for faster startup",
@@ -294,14 +306,33 @@ export async function launchClaudeCode(
           ),
         );
         console.log("");
-        await new Promise((resolve) => setTimeout(resolve, 2000));
-        await execInteractive("bunx", [CLAUDE_CLI_PACKAGE, ...args], {
-          cwd: worktreePath,
-          stdin: childStdio.stdin,
-          stdout: childStdio.stdout,
-          stderr: childStdio.stderr,
-          env: launchEnv,
-        });
+        const shouldSkipDelay =
+          typeof process !== "undefined" &&
+          (process.env?.NODE_ENV === "test" || Boolean(process.env?.VITEST));
+        if (!shouldSkipDelay) {
+          await new Promise((resolve) => setTimeout(resolve, 2000));
+        }
+        if (useNpx && npxLookup?.path) {
+          await execInteractive(
+            npxLookup.path,
+            ["-y", CLAUDE_CLI_PACKAGE, ...args],
+            {
+              cwd: worktreePath,
+              stdin: childStdio.stdin,
+              stdout: childStdio.stdout,
+              stderr: childStdio.stderr,
+              env: launchEnv,
+            },
+          );
+        } else {
+          await execInteractive("bunx", [CLAUDE_CLI_PACKAGE, ...args], {
+            cwd: worktreePath,
+            stdin: childStdio.stdin,
+            stdout: childStdio.stdout,
+            stderr: childStdio.stderr,
+            env: launchEnv,
+          });
+        }
       }
     } finally {
       childStdio.cleanup();
@@ -342,7 +373,9 @@ export async function launchClaudeCode(
 
     return capturedSessionId ? { sessionId: capturedSessionId } : {};
   } catch (error: unknown) {
-    const hasLocalClaude = await isClaudeCommandAvailable();
+    const claudeCheck = await findCommand("claude");
+    const hasLocalClaude =
+      claudeCheck.source === "installed" && claudeCheck.path !== null;
     let errorMessage: string;
     const err = error as NodeJS.ErrnoException;
 
@@ -394,10 +427,6 @@ export async function launchClaudeCode(
   }
 }
 
-async function isClaudeCommandAvailable(): Promise<boolean> {
-  return isCommandAvailable("claude");
-}
-
 /**
  * Checks whether Claude Code is available via `bunx` in the current environment.
  *

package/src/cli/ui/__tests__/components/App.shortcuts.test.tsx

@@ -176,7 +176,7 @@ describe("App shortcuts integration", () => {
     getRepositoryRootMock.mockResolvedValue("/repo");
     deleteBranchMock.mockResolvedValue(undefined);
     App = (await import("../../components/App.js")).App;
-  });
+  }, 30000);
 
   afterEach(() => {
     useGitDataMock.mockReset();
@@ -380,9 +380,13 @@ describe("App shortcuts integration", () => {
       expect(latestProps?.cleanupUI?.footerMessage?.text).toBeTruthy();
       expect(latestProps?.cleanupUI?.indicators).toMatchObject({
         "feature/add-new-feature": expect.objectContaining({
-          icon: expect.stringMatching(/⠋|⠙|⠹|⠸|⠼|⠴|⠦|⠧/),
+          isSpinning: true,
+          color: "cyan",
+        }),
+        "hotfix/urgent-fix": expect.objectContaining({
+          icon: "⏳",
+          color: "yellow",
         }),
-        "hotfix/urgent-fix": expect.objectContaining({ icon: "⏳" }),
       });
 
       resolveRemoveWorktree?.();

package/src/cli/ui/__tests__/components/common/Select.test.tsx

@@ -6,6 +6,7 @@ import { describe, it, expect, vi } from "vitest";
 import { render } from "ink-testing-library";
 import React from "react";
 import { Select } from "../../../components/common/Select.js";
+import { ESCAPE_SEQUENCE_TIMEOUT_MS } from "../../../hooks/useAppInput.js";
 
 interface TestItem {
   label: string;
@@ -285,43 +286,48 @@ describe("Select", () => {
     });
   });
 
-  describe('Space/Escape handlers', () => {
-    it('should call onSpace with the currently highlighted item', async () => {
+  describe("Space/Escape handlers", () => {
+    it("should call onSpace with the currently highlighted item", async () => {
       const onSelect = vi.fn();
       const onSpace = vi.fn();
       const { stdin } = render(
-        <Select items={mockItems} onSelect={onSelect} onSpace={onSpace} />
+        <Select items={mockItems} onSelect={onSelect} onSpace={onSpace} />,
       );
 
-      stdin.write(' ');
+      stdin.write(" ");
       await delay(10);
 
       expect(onSpace).toHaveBeenCalledTimes(1);
       expect(onSpace).toHaveBeenCalledWith(mockItems[0]);
     });
 
-    it('should not trigger onSpace when disabled', async () => {
+    it("should not trigger onSpace when disabled", async () => {
       const onSelect = vi.fn();
       const onSpace = vi.fn();
       const { stdin } = render(
-        <Select items={mockItems} onSelect={onSelect} onSpace={onSpace} disabled />
+        <Select
+          items={mockItems}
+          onSelect={onSelect}
+          onSpace={onSpace}
+          disabled
+        />,
       );
 
-      stdin.write(' ');
+      stdin.write(" ");
       await delay(10);
 
       expect(onSpace).not.toHaveBeenCalled();
     });
 
-    it('should call onEscape when escape key is pressed', async () => {
+    it("should call onEscape when escape key is pressed", async () => {
       const onSelect = vi.fn();
       const onEscape = vi.fn();
       const { stdin } = render(
-        <Select items={mockItems} onSelect={onSelect} onEscape={onEscape} />
+        <Select items={mockItems} onSelect={onSelect} onEscape={onEscape} />,
       );
 
-      stdin.write('\u001B');
-      await delay(30);
+      stdin.write("\u001B");
+      await delay(ESCAPE_SEQUENCE_TIMEOUT_MS + 20);
 
       expect(onEscape).toHaveBeenCalledTimes(1);
     });

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

@@ -210,7 +210,7 @@ describe("BranchListScreen", () => {
       />,
     );
 
-    const text = container.textContent ?? "";
+    const text = stripAnsi(container.textContent ?? "");
     expect(text).toMatch(/\[ \]\s(🟢|🔴|⚪)\s(🛡|⚠)/); // state cluster with spacing
   });
 
@@ -724,10 +724,11 @@ describe("BranchListScreen", () => {
       expect(container.textContent).toContain("feature/test");
     });
 
-    it("should disable other key bindings (c, r) while typing in filter", () => {
+    it("should disable other key bindings (c, r, l) while typing in filter", () => {
       const onSelect = vi.fn();
       const onCleanupCommand = vi.fn();
       const onRefresh = vi.fn();
+      const onOpenLogs = vi.fn();
 
       const inkApp = inkRender(
         <BranchListScreen
@@ -736,6 +737,7 @@ describe("BranchListScreen", () => {
           onSelect={onSelect}
           onCleanupCommand={onCleanupCommand}
           onRefresh={onRefresh}
+          onOpenLogs={onOpenLogs}
         />,
       );
 
@@ -746,10 +748,34 @@ describe("BranchListScreen", () => {
       act(() => {
         inkApp.stdin.write("c");
         inkApp.stdin.write("r");
+        inkApp.stdin.write("l");
       });
 
       expect(onCleanupCommand).not.toHaveBeenCalled();
       expect(onRefresh).not.toHaveBeenCalled();
+      expect(onOpenLogs).not.toHaveBeenCalled();
+
+      inkApp.unmount();
+    });
+
+    it("should open logs on l key", () => {
+      const onSelect = vi.fn();
+      const onOpenLogs = vi.fn();
+
+      const inkApp = inkRender(
+        <BranchListScreen
+          branches={mockBranches}
+          stats={mockStats}
+          onSelect={onSelect}
+          onOpenLogs={onOpenLogs}
+        />,
+      );
+
+      act(() => {
+        inkApp.stdin.write("l");
+      });
+
+      expect(onOpenLogs).toHaveBeenCalled();
 
       inkApp.unmount();
     });

package/src/cli/ui/__tests__/components/screens/LogDetailScreen.test.tsx

@@ -0,0 +1,57 @@
+/**
+ * @vitest-environment happy-dom
+ */
+import { describe, it, expect, vi } from "vitest";
+import { act } from "@testing-library/react";
+import { render as inkRender } from "ink-testing-library";
+import React from "react";
+import { LogDetailScreen } from "../../../components/screens/LogDetailScreen.js";
+import type { FormattedLogEntry } from "../../../../../logging/formatter.js";
+
+const entry: FormattedLogEntry = {
+  id: "entry-1",
+  raw: {
+    time: "2025-12-25T10:00:00.000Z",
+    level: 30,
+    category: "cli",
+    msg: "hello",
+  },
+  timestamp: 1_767_015_200_000,
+  timeLabel: "10:00:00",
+  levelLabel: "INFO",
+  category: "cli",
+  message: "hello",
+  summary: "[10:00:00] [INFO] [cli] hello",
+  json: '{\n  "msg": "hello"\n}',
+};
+
+describe("LogDetailScreen", () => {
+  it("renders formatted JSON and handles shortcuts", () => {
+    const onBack = vi.fn();
+    const onCopy = vi.fn();
+
+    const { stdin, lastFrame } = inkRender(
+      <LogDetailScreen entry={entry} onBack={onBack} onCopy={onCopy} />,
+    );
+
+    expect(lastFrame()).toContain('"msg": "hello"');
+
+    act(() => {
+      stdin.write("c");
+    });
+    expect(onCopy).toHaveBeenCalledWith(entry);
+
+    act(() => {
+      stdin.write("q");
+    });
+    expect(onBack).toHaveBeenCalled();
+  });
+
+  it("shows fallback when entry is missing", () => {
+    const { lastFrame } = inkRender(
+      <LogDetailScreen entry={null} onBack={vi.fn()} onCopy={vi.fn()} />,
+    );
+
+    expect(lastFrame()).toContain("ログがありません");
+  });
+});

package/src/cli/ui/__tests__/components/screens/LogListScreen.test.tsx

@@ -0,0 +1,102 @@
+/**
+ * @vitest-environment happy-dom
+ */
+import { describe, it, expect, vi } from "vitest";
+import { act } from "@testing-library/react";
+import { render as inkRender } from "ink-testing-library";
+import React from "react";
+import { LogListScreen } from "../../../components/screens/LogListScreen.js";
+import type { FormattedLogEntry } from "../../../../../logging/formatter.js";
+
+const buildEntry = (
+  overrides: Partial<FormattedLogEntry>,
+): FormattedLogEntry => ({
+  id: "entry-1",
+  raw: {
+    time: "2025-12-25T10:00:00.000Z",
+    level: 30,
+    category: "cli",
+    msg: "hello",
+  },
+  timestamp: 1_767_015_200_000,
+  timeLabel: "10:00:00",
+  levelLabel: "INFO",
+  category: "cli",
+  message: "hello",
+  summary: "[10:00:00] [INFO] [cli] hello",
+  json: '{\n  "msg": "hello"\n}',
+  ...overrides,
+});
+
+describe("LogListScreen", () => {
+  it("renders log entries and handles shortcuts", () => {
+    const entries: FormattedLogEntry[] = [
+      buildEntry({ id: "entry-1" }),
+      buildEntry({
+        id: "entry-2",
+        summary: "[10:01:00] [WARN] [server] warn",
+        levelLabel: "WARN",
+        category: "server",
+        message: "warn",
+      }),
+    ];
+
+    const onSelect = vi.fn();
+    const onBack = vi.fn();
+    const onCopy = vi.fn();
+    const onPickDate = vi.fn();
+
+    const { stdin, lastFrame } = inkRender(
+      <LogListScreen
+        entries={entries}
+        loading={false}
+        error={null}
+        onBack={onBack}
+        onSelect={onSelect}
+        onCopy={onCopy}
+        onPickDate={onPickDate}
+        selectedDate="2025-12-25"
+      />,
+    );
+
+    const frame = lastFrame();
+    expect(frame).toContain("[10:00:00] [INFO] [cli] hello");
+    expect(frame).toContain("[10:01:00] [WARN] [server] warn");
+
+    act(() => {
+      stdin.write("\r");
+    });
+    expect(onSelect).toHaveBeenCalledWith(entries[0]);
+
+    act(() => {
+      stdin.write("c");
+    });
+    expect(onCopy).toHaveBeenCalledWith(entries[0]);
+
+    act(() => {
+      stdin.write("d");
+    });
+    expect(onPickDate).toHaveBeenCalled();
+
+    act(() => {
+      stdin.write("q");
+    });
+    expect(onBack).toHaveBeenCalled();
+  });
+
+  it("shows empty message when no logs", () => {
+    const { lastFrame } = inkRender(
+      <LogListScreen
+        entries={[]}
+        loading={false}
+        error={null}
+        onBack={vi.fn()}
+        onSelect={vi.fn()}
+        onCopy={vi.fn()}
+        selectedDate="2025-12-25"
+      />,
+    );
+
+    expect(lastFrame()).toContain("ログがありません");
+  });
+});

package/src/cli/ui/__tests__/hooks/useGitData.test.ts

@@ -0,0 +1,197 @@
+/**
+ * @vitest-environment happy-dom
+ */
+import { describe, it, expect, beforeEach, vi, afterEach } from "vitest";
+import { renderHook, act, waitFor } from "@testing-library/react";
+import { Window } from "happy-dom";
+
+// モジュールをモック
+vi.mock("../../../../git.js", () => ({
+  getAllBranches: vi.fn(),
+  hasUnpushedCommitsInRepo: vi.fn(),
+  getRepositoryRoot: vi.fn(),
+  fetchAllRemotes: vi.fn(),
+  collectUpstreamMap: vi.fn(),
+  getBranchDivergenceStatuses: vi.fn(),
+  hasUncommittedChanges: vi.fn(),
+}));
+
+vi.mock("../../../../worktree.js", () => ({
+  listAdditionalWorktrees: vi.fn(),
+}));
+
+vi.mock("../../../../github.js", () => ({
+  getPullRequestByBranch: vi.fn(),
+}));
+
+vi.mock("../../../../config/index.js", () => ({
+  getLastToolUsageMap: vi.fn(),
+}));
+
+import { useGitData } from "../../hooks/useGitData.js";
+import {
+  getAllBranches,
+  getRepositoryRoot,
+  fetchAllRemotes,
+  collectUpstreamMap,
+  getBranchDivergenceStatuses,
+} from "../../../../git.js";
+import { listAdditionalWorktrees } from "../../../../worktree.js";
+import { getLastToolUsageMap } from "../../../../config/index.js";
+
+const mockGetAllBranches = getAllBranches as ReturnType<typeof vi.fn>;
+const mockGetRepositoryRoot = getRepositoryRoot as ReturnType<typeof vi.fn>;
+const mockFetchAllRemotes = fetchAllRemotes as ReturnType<typeof vi.fn>;
+const mockCollectUpstreamMap = collectUpstreamMap as ReturnType<typeof vi.fn>;
+const mockGetBranchDivergenceStatuses =
+  getBranchDivergenceStatuses as ReturnType<typeof vi.fn>;
+const mockListAdditionalWorktrees = listAdditionalWorktrees as ReturnType<
+  typeof vi.fn
+>;
+const mockGetLastToolUsageMap = getLastToolUsageMap as ReturnType<typeof vi.fn>;
+
+describe("useGitData", () => {
+  beforeEach(() => {
+    // Setup happy-dom
+    const window = new Window();
+    globalThis.window = window as unknown as typeof globalThis.window;
+    globalThis.document =
+      window.document as unknown as typeof globalThis.document;
+
+    // Reset all mocks
+    vi.clearAllMocks();
+
+    // Default mock implementations
+    mockGetRepositoryRoot.mockResolvedValue("/mock/repo");
+    mockFetchAllRemotes.mockResolvedValue(undefined);
+    mockGetAllBranches.mockResolvedValue([
+      {
+        name: "main",
+        type: "local",
+        isCurrent: true,
+        lastCommitDate: "2025-01-01",
+      },
+      {
+        name: "develop",
+        type: "local",
+        isCurrent: false,
+        lastCommitDate: "2025-01-02",
+      },
+    ]);
+    mockListAdditionalWorktrees.mockResolvedValue([]);
+    mockCollectUpstreamMap.mockResolvedValue(new Map());
+    mockGetBranchDivergenceStatuses.mockResolvedValue([]);
+    mockGetLastToolUsageMap.mockResolvedValue(new Map());
+  });
+
+  afterEach(() => {
+    vi.restoreAllMocks();
+  });
+
+  describe("キャッシュ機構", () => {
+    it("初回マウント時にGitデータを取得する", async () => {
+      const { result } = renderHook(() => useGitData());
+
+      // 初回ロード中
+      expect(result.current.loading).toBe(true);
+
+      await waitFor(() => {
+        expect(result.current.loading).toBe(false);
+      });
+
+      // Gitデータが取得されていることを確認
+      expect(mockGetAllBranches).toHaveBeenCalledTimes(1);
+      expect(result.current.branches).toHaveLength(2);
+    });
+
+    it("refresh()を呼び出すとGitデータを再取得する", async () => {
+      const { result } = renderHook(() => useGitData());
+
+      await waitFor(() => {
+        expect(result.current.loading).toBe(false);
+      });
+
+      // 初回ロードで1回呼ばれている
+      expect(mockGetAllBranches).toHaveBeenCalledTimes(1);
+
+      // refresh()を呼び出す
+      await act(async () => {
+        result.current.refresh();
+      });
+
+      await waitFor(() => {
+        expect(result.current.loading).toBe(false);
+      });
+
+      // refresh後に再度呼ばれている（forceRefresh=true）
+      expect(mockGetAllBranches).toHaveBeenCalledTimes(2);
+    });
+
+    it("キャッシュ済みの場合、再マウント時にGitデータを再取得しない", async () => {
+      // 注: useGitData は内部で useRef を使ってキャッシュ状態を管理
+      // 同一コンポーネント内での再レンダリングではキャッシュが効く
+      const { result, rerender } = renderHook(() => useGitData());
+
+      await waitFor(() => {
+        expect(result.current.loading).toBe(false);
+      });
+
+      // 初回ロードで1回呼ばれている
+      expect(mockGetAllBranches).toHaveBeenCalledTimes(1);
+
+      // 再レンダリング
+      rerender();
+
+      // キャッシュされているため追加の呼び出しはない
+      expect(mockGetAllBranches).toHaveBeenCalledTimes(1);
+    });
+  });
+
+  describe("lastUpdated", () => {
+    it("データ取得成功後にlastUpdatedが更新される", async () => {
+      const { result } = renderHook(() => useGitData());
+
+      // 初期状態ではnull
+      expect(result.current.lastUpdated).toBeNull();
+
+      await waitFor(() => {
+        expect(result.current.loading).toBe(false);
+      });
+
+      // ロード完了後にlastUpdatedが設定される
+      expect(result.current.lastUpdated).toBeInstanceOf(Date);
+    });
+  });
+
+  describe("エラーハンドリング", () => {
+    it("getAllBranchesがエラーを投げた場合、フォールバック値（空配列）が使用される", async () => {
+      // withTimeout がエラーをキャッチしてフォールバック値を返すため、
+      // エラー状態にはならず、空配列が設定される
+      mockGetAllBranches.mockRejectedValue(new Error("Git error"));
+
+      const { result } = renderHook(() => useGitData());
+
+      await waitFor(() => {
+        expect(result.current.loading).toBe(false);
+      });
+
+      // エラーはキャッチされ、フォールバック値が使用される
+      expect(result.current.error).toBeNull();
+      expect(result.current.branches).toHaveLength(0);
+    });
+
+    it("fetchAllRemotesがエラーを投げてもローカル表示は継続される", async () => {
+      mockFetchAllRemotes.mockRejectedValue(new Error("Network error"));
+
+      const { result } = renderHook(() => useGitData());
+
+      await waitFor(() => {
+        expect(result.current.loading).toBe(false);
+      });
+
+      // リモート取得失敗でもローカルブランチは表示される
+      expect(result.current.branches).toHaveLength(2);
+      expect(result.current.error).toBeNull();
+    });
+  });
+});