@akiojin/gwt 4.6.1 → 4.7.0

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();
+    });
+  });
+});

package/src/cli/ui/__tests__/integration/edgeCases.test.tsx

@@ -13,7 +13,14 @@ import type { BranchInfo, BranchItem, Statistics } from "../../types.js";
 const mockRefresh = vi.fn();
 const branchListProps: BranchListScreenProps[] = [];
 const useGitDataMock = vi.fn();
-let App: typeof import("../../components/App.js").App;
+let App: typeof import("../../components/App.js").App | null = null;
+
+const loadApp = async () => {
+  if (!App) {
+    App = (await import("../../components/App.js")).App;
+  }
+  return App;
+};
 
 vi.mock("../../hooks/useGitData.js", () => ({
   useGitData: (...args: unknown[]) => useGitDataMock(...args),
@@ -53,7 +60,6 @@ describe("Edge Cases Integration Tests", () => {
     vi.clearAllMocks();
     useGitDataMock.mockReset();
     branchListProps.length = 0;
-    App = (await import("../../components/App.js")).App;
   });
 
   /**
@@ -237,13 +243,14 @@ describe("Edge Cases Integration Tests", () => {
     });
 
     const onExit = vi.fn();
-    const { container } = render(<App onExit={onExit} />);
+    const AppComponent = await loadApp();
+    const { container } = render(<AppComponent onExit={onExit} />);
 
     // Initial render should work
     expect(container).toBeDefined();
   });
 
-  it("[T093] should display error message when data loading fails", () => {
+  it("[T093] should display error message when data loading fails", async () => {
     const testError = new Error("Test error: Failed to load Git data");
     useGitDataMock.mockReturnValue({
       branches: [],
@@ -255,7 +262,8 @@ describe("Edge Cases Integration Tests", () => {
     });
 
     const onExit = vi.fn();
-    const { getByText } = render(<App onExit={onExit} />);
+    const AppComponent = await loadApp();
+    const { getByText } = render(<AppComponent onExit={onExit} />);
 
     expect(branchListProps).not.toHaveLength(0);
     expect(branchListProps.at(-1)?.error).toBe(testError);
@@ -264,7 +272,7 @@ describe("Edge Cases Integration Tests", () => {
     expect(getByText(/Failed to load Git data/i)).toBeDefined();
   });
 
-  it("[T093] should handle empty branches list gracefully", () => {
+  it("[T093] should handle empty branches list gracefully", async () => {
     useGitDataMock.mockReturnValue({
       branches: [],
       worktrees: [],
@@ -275,7 +283,8 @@ describe("Edge Cases Integration Tests", () => {
     });
 
     const onExit = vi.fn();
-    const { container } = render(<App onExit={onExit} />);
+    const AppComponent = await loadApp();
+    const { container } = render(<AppComponent onExit={onExit} />);
 
     // Should render without error even with no branches
     expect(container).toBeDefined();
@@ -284,7 +293,7 @@ describe("Edge Cases Integration Tests", () => {
   /**
    * Additional edge cases
    */
-  it("should handle large number of worktrees", () => {
+  it("should handle large number of worktrees", async () => {
     const mockBranches: BranchInfo[] = Array.from({ length: 50 }, (_, i) => ({
       name: `feature/branch-${i}`,
       type: "local" as const,
@@ -307,7 +316,8 @@ describe("Edge Cases Integration Tests", () => {
     });
 
     const onExit = vi.fn();
-    const { container } = render(<App onExit={onExit} />);
+    const AppComponent = await loadApp();
+    const { container } = render(<AppComponent onExit={onExit} />);
 
     expect(container).toBeDefined();
   });

package/src/cli/ui/__tests__/utils/clipboard.test.ts

@@ -0,0 +1,65 @@
+import { describe, it, expect, vi } from "vitest";
+import { copyToClipboard } from "../../utils/clipboard.js";
+
+const execaMock = vi.fn();
+
+vi.mock("execa", () => ({
+  execa: (...args: unknown[]) => execaMock(...args),
+}));
+
+describe("copyToClipboard", () => {
+  it("uses pbcopy on darwin", async () => {
+    execaMock.mockResolvedValue({ stdout: "" });
+
+    await copyToClipboard("hello", {
+      platform: "darwin",
+      execa: execaMock as unknown as typeof import("execa").execa,
+    });
+
+    expect(execaMock).toHaveBeenCalledWith(
+      "pbcopy",
+      [],
+      expect.objectContaining({ input: "hello" }),
+    );
+  });
+
+  it("falls back to xsel when xclip fails", async () => {
+    execaMock.mockImplementation((command: string) => {
+      if (command === "xclip") {
+        return Promise.reject(new Error("missing"));
+      }
+      return Promise.resolve({ stdout: "" });
+    });
+
+    await copyToClipboard("hello", {
+      platform: "linux",
+      execa: execaMock as unknown as typeof import("execa").execa,
+    });
+
+    expect(execaMock).toHaveBeenCalledWith(
+      "xclip",
+      ["-selection", "clipboard"],
+      expect.objectContaining({ input: "hello" }),
+    );
+    expect(execaMock).toHaveBeenCalledWith(
+      "xsel",
+      ["--clipboard", "--input"],
+      expect.objectContaining({ input: "hello" }),
+    );
+  });
+
+  it("uses clip on windows", async () => {
+    execaMock.mockResolvedValue({ stdout: "" });
+
+    await copyToClipboard("hello", {
+      platform: "win32",
+      execa: execaMock as unknown as typeof import("execa").execa,
+    });
+
+    expect(execaMock).toHaveBeenCalledWith(
+      "cmd",
+      ["/c", "clip"],
+      expect.objectContaining({ input: "hello" }),
+    );
+  });
+});

package/src/cli/ui/components/App.tsx

@@ -11,6 +11,9 @@ import {
   BranchListScreen,
   type BranchListScreenProps,
 } from "./screens/BranchListScreen.js";
+import { LogListScreen } from "./screens/LogListScreen.js";
+import { LogDetailScreen } from "./screens/LogDetailScreen.js";
+import { LogDatePickerScreen } from "./screens/LogDatePickerScreen.js";
 import { BranchCreatorScreen } from "./screens/BranchCreatorScreen.js";
 import { BranchActionSelectorScreen } from "../screens/BranchActionSelectorScreen.js";
 import { AIToolSelectorScreen } from "./screens/AIToolSelectorScreen.js";
@@ -29,6 +32,19 @@ import { useScreenState } from "../hooks/useScreenState.js";
 import { useToolStatus } from "../hooks/useToolStatus.js";
 import { formatBranchItems } from "../utils/branchFormatter.js";
 import { calculateStatistics } from "../utils/statisticsCalculator.js";
+import { copyToClipboard } from "../utils/clipboard.js";
+import {
+  parseLogLines,
+  type FormattedLogEntry,
+} from "../../../logging/formatter.js";
+import {
+  buildLogFilePath,
+  getTodayLogDate,
+  listRecentLogFiles,
+  readLogFileLines,
+  resolveLogDir,
+  type LogFileInfo,
+} from "../../../logging/reader.js";
 import type {
   AITool,
   BranchInfo,
@@ -131,6 +147,26 @@ export function App({ onExit, loadingIndicatorDelay = 300 }: AppProps) {
   >([]);
   const [branchQuickStartLoading, setBranchQuickStartLoading] = useState(false);
 
+  // Log viewer state
+  const logDir = useMemo(
+    () => resolveLogDir(workingDirectory),
+    [workingDirectory],
+  );
+  const [logEntries, setLogEntries] = useState<FormattedLogEntry[]>([]);
+  const [logLoading, setLogLoading] = useState(false);
+  const [logError, setLogError] = useState<string | null>(null);
+  const [logSelectedDate, setLogSelectedDate] = useState<string | null>(
+    getTodayLogDate(),
+  );
+  const [logDates, setLogDates] = useState<LogFileInfo[]>([]);
+  const [logSelectedEntry, setLogSelectedEntry] =
+    useState<FormattedLogEntry | null>(null);
+  const [logNotification, setLogNotification] = useState<{
+    message: string;
+    tone: "success" | "error";
+  } | null>(null);
+  const logNotificationTimerRef = useRef<NodeJS.Timeout | null>(null);
+
   // Selection state (for branch → tool → mode flow)
   const [selectedBranch, setSelectedBranch] =
     useState<SelectedBranchState | null>(null);
@@ -182,6 +218,70 @@ export function App({ onExit, loadingIndicatorDelay = 300 }: AppProps) {
       .catch(() => setRepoRoot(null));
   }, []);
 
+  const showLogNotification = useCallback(
+    (message: string, tone: "success" | "error" = "success") => {
+      setLogNotification({ message, tone });
+      if (logNotificationTimerRef.current) {
+        clearTimeout(logNotificationTimerRef.current);
+      }
+      logNotificationTimerRef.current = setTimeout(() => {
+        setLogNotification(null);
+      }, 2000);
+    },
+    [],
+  );
+
+  useEffect(() => {
+    return () => {
+      if (logNotificationTimerRef.current) {
+        clearTimeout(logNotificationTimerRef.current);
+      }
+    };
+  }, []);
+
+  const loadLogEntries = useCallback(
+    async (date: string | null) => {
+      const targetDate = date ?? getTodayLogDate();
+      setLogLoading(true);
+      setLogError(null);
+      try {
+        const filePath = buildLogFilePath(logDir, targetDate);
+        const lines = await readLogFileLines(filePath);
+        const parsed = parseLogLines(lines, { limit: 100 });
+        setLogEntries(parsed);
+      } catch (error) {
+        setLogEntries([]);
+        setLogError(
+          error instanceof Error ? error.message : "Failed to load logs",
+        );
+      } finally {
+        setLogLoading(false);
+      }
+    },
+    [logDir],
+  );
+
+  const loadLogDates = useCallback(async () => {
+    try {
+      const files = await listRecentLogFiles(logDir, 7);
+      setLogDates(files);
+    } catch {
+      setLogDates([]);
+    }
+  }, [logDir]);
+
+  useEffect(() => {
+    if (currentScreen === "log-list") {
+      void loadLogEntries(logSelectedDate);
+    }
+  }, [currentScreen, loadLogEntries, logSelectedDate]);
+
+  useEffect(() => {
+    if (currentScreen === "log-date-picker") {
+      void loadLogDates();
+    }
+  }, [currentScreen, loadLogDates]);
+
   useEffect(() => {
     if (!hiddenBranches.length) {
       return;
@@ -720,6 +820,45 @@ export function App({ onExit, loadingIndicatorDelay = 300 }: AppProps) {
     exit();
   }, [onExit, exit]);
 
+  const handleOpenLogs = useCallback(() => {
+    setLogSelectedDate(getTodayLogDate());
+    setLogSelectedEntry(null);
+    navigateTo("log-list");
+  }, [navigateTo]);
+
+  const handleSelectLogEntry = useCallback(
+    (entry: FormattedLogEntry) => {
+      setLogSelectedEntry(entry);
+      navigateTo("log-detail");
+    },
+    [navigateTo],
+  );
+
+  const handleCopyLogEntry = useCallback(
+    async (entry: FormattedLogEntry) => {
+      try {
+        await copyToClipboard(entry.json);
+        showLogNotification("Copied to clipboard.", "success");
+      } catch {
+        showLogNotification("Failed to copy to clipboard.", "error");
+      }
+    },
+    [showLogNotification],
+  );
+
+  const handleOpenLogDates = useCallback(() => {
+    navigateTo("log-date-picker");
+  }, [navigateTo]);
+
+  const handleSelectLogDate = useCallback(
+    (date: string) => {
+      setLogSelectedDate(date);
+      setLogSelectedEntry(null);
+      navigateTo("log-list");
+    },
+    [navigateTo],
+  );
+
   // Handle branch creation
   const handleCreate = useCallback(
     async (branchName: string) => {
@@ -1150,6 +1289,7 @@ export function App({ onExit, loadingIndicatorDelay = 300 }: AppProps) {
         workingDirectory={workingDirectory}
         activeProfile={activeProfileName}
         onOpenProfiles={() => navigateTo("environment-profile")}
+        onOpenLogs={handleOpenLogs}
         toolStatuses={toolStatuses}
         {...additionalProps}
       />
@@ -1168,6 +1308,43 @@ export function App({ onExit, loadingIndicatorDelay = 300 }: AppProps) {
           onToggleSelect: toggleBranchSelection,
         });
 
+      case "log-list":
+        return (
+          <LogListScreen
+            entries={logEntries}
+            loading={logLoading}
+            error={logError}
+            onBack={goBack}
+            onSelect={handleSelectLogEntry}
+            onCopy={handleCopyLogEntry}
+            onPickDate={handleOpenLogDates}
+            notification={logNotification}
+            version={version}
+            selectedDate={logSelectedDate}
+          />
+        );
+
+      case "log-detail":
+        return (
+          <LogDetailScreen
+            entry={logSelectedEntry}
+            onBack={goBack}
+            onCopy={handleCopyLogEntry}
+            notification={logNotification}
+            version={version}
+          />
+        );
+
+      case "log-date-picker":
+        return (
+          <LogDatePickerScreen
+            dates={logDates}
+            onBack={goBack}
+            onSelect={handleSelectLogDate}
+            version={version}
+          />
+        );
+
       case "branch-creator":
         return (
           <BranchCreatorScreen