@akiojin/gwt 2.0.0

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

@@ -0,0 +1,313 @@
+/**
+ * @vitest-environment happy-dom
+ */
+import { describe, it, expect, beforeEach, afterEach, afterAll, vi } from 'vitest';
+import type { Mock } from 'vitest';
+import { render, act, waitFor } from '@testing-library/react';
+import React from 'react';
+import type { BranchItem, CleanupTarget } from '../../types.js';
+import { Window } from 'happy-dom';
+import * as useGitDataModule from '../../hooks/useGitData.js';
+import * as useScreenStateModule from '../../hooks/useScreenState.js';
+import * as WorktreeManagerScreenModule from '../../components/screens/WorktreeManagerScreen.js';
+import * as BranchCreatorScreenModule from '../../components/screens/BranchCreatorScreen.js';
+import * as BranchListScreenModule from '../../components/screens/BranchListScreen.js';
+import * as worktreeModule from '../../../../worktree.ts';
+import * as gitModule from '../../../../git.ts';
+import { App } from '../../components/App.js';
+
+const navigateToMock = vi.fn();
+const goBackMock = vi.fn();
+const resetMock = vi.fn();
+
+const worktreeScreenProps: any[] = [];
+const branchCreatorProps: any[] = [];
+const branchListProps: any[] = [];
+
+const originalUseGitData = useGitDataModule.useGitData;
+const originalUseScreenState = useScreenStateModule.useScreenState;
+const originalWorktreeManagerScreen = WorktreeManagerScreenModule.WorktreeManagerScreen;
+const originalBranchCreatorScreen = BranchCreatorScreenModule.BranchCreatorScreen;
+const originalBranchListScreen = BranchListScreenModule.BranchListScreen;
+const originalGetMergedPRWorktrees = worktreeModule.getMergedPRWorktrees;
+const originalGenerateWorktreePath = worktreeModule.generateWorktreePath;
+const originalCreateWorktree = worktreeModule.createWorktree;
+const originalRemoveWorktree = worktreeModule.removeWorktree;
+const originalGetRepositoryRoot = gitModule.getRepositoryRoot;
+const originalDeleteBranch = gitModule.deleteBranch;
+
+const useGitDataSpy = vi.spyOn(useGitDataModule, 'useGitData');
+const useScreenStateSpy = vi.spyOn(useScreenStateModule, 'useScreenState');
+const worktreeManagerScreenSpy = vi.spyOn(WorktreeManagerScreenModule, 'WorktreeManagerScreen');
+const branchCreatorScreenSpy = vi.spyOn(BranchCreatorScreenModule, 'BranchCreatorScreen');
+const branchListScreenSpy = vi.spyOn(BranchListScreenModule, 'BranchListScreen');
+const getMergedPRWorktreesSpy = vi.spyOn(worktreeModule, 'getMergedPRWorktrees');
+const generateWorktreePathSpy = vi.spyOn(worktreeModule, 'generateWorktreePath');
+const createWorktreeSpy = vi.spyOn(worktreeModule, 'createWorktree');
+const removeWorktreeSpy = vi.spyOn(worktreeModule, 'removeWorktree');
+const getRepositoryRootSpy = vi.spyOn(gitModule, 'getRepositoryRoot');
+const deleteBranchSpy = vi.spyOn(gitModule, 'deleteBranch');
+
+describe('App shortcuts integration', () => {
+  beforeEach(() => {
+    if (typeof globalThis.document === 'undefined') {
+      const window = new Window();
+      globalThis.window = window as any;
+      globalThis.document = window.document as any;
+    }
+    worktreeScreenProps.length = 0;
+    branchCreatorProps.length = 0;
+    branchListProps.length = 0;
+    navigateToMock.mockClear();
+    goBackMock.mockClear();
+    resetMock.mockClear();
+    useGitDataSpy.mockImplementation(() => ({
+      branches: [],
+      worktrees: [
+        {
+          branch: 'feature/existing',
+          path: '/worktrees/feature-existing',
+          isAccessible: true,
+        },
+      ],
+      loading: false,
+      error: null,
+      refresh: vi.fn(),
+      lastUpdated: null,
+    }));
+    useScreenStateSpy.mockImplementation(() => ({
+      currentScreen: 'worktree-manager',
+      navigateTo: navigateToMock as _Mock,
+      goBack: goBackMock as _Mock,
+      reset: resetMock as _Mock,
+    }));
+    worktreeManagerScreenSpy.mockImplementation((props: any) => {
+      worktreeScreenProps.push(props);
+      return React.createElement(originalWorktreeManagerScreen, props);
+    });
+    branchCreatorScreenSpy.mockImplementation((props: any) => {
+      branchCreatorProps.push(props);
+      return React.createElement(originalBranchCreatorScreen, props);
+    });
+    branchListScreenSpy.mockImplementation((props: any) => {
+      branchListProps.push(props);
+      return React.createElement(originalBranchListScreen, props);
+    });
+    getMergedPRWorktreesSpy.mockResolvedValue([
+      {
+        branch: 'feature/add-new-feature',
+        cleanupType: 'worktree-and-branch',
+        pullRequest: {
+          number: 123,
+          title: 'Add new feature',
+          branch: 'feature/add-new-feature',
+          mergedAt: '2025-01-20T10:00:00Z',
+          author: 'user1',
+        },
+        worktreePath: '/worktrees/feature-add-new-feature',
+        hasUncommittedChanges: false,
+        hasUnpushedCommits: false,
+        hasRemoteBranch: true,
+        isAccessible: true,
+      },
+      {
+        branch: 'hotfix/urgent-fix',
+        cleanupType: 'worktree-and-branch',
+        pullRequest: {
+          number: 456,
+          title: 'Urgent fix',
+          branch: 'hotfix/urgent-fix',
+          mergedAt: '2025-01-21T09:00:00Z',
+          author: 'user2',
+        },
+        worktreePath: '/worktrees/hotfix-urgent-fix',
+        hasUncommittedChanges: true,
+        hasUnpushedCommits: false,
+        hasRemoteBranch: true,
+        isAccessible: true,
+      },
+    ] as CleanupTarget[]);
+    generateWorktreePathSpy.mockResolvedValue('/worktrees/new-branch');
+    createWorktreeSpy.mockResolvedValue(undefined);
+    removeWorktreeSpy.mockResolvedValue(undefined);
+    getRepositoryRootSpy.mockResolvedValue('/repo');
+    deleteBranchSpy.mockResolvedValue(undefined);
+  });
+
+  afterEach(() => {
+    useGitDataSpy.mockReset();
+    useScreenStateSpy.mockReset();
+    worktreeManagerScreenSpy.mockReset();
+    branchCreatorScreenSpy.mockReset();
+    branchListScreenSpy.mockReset();
+    getMergedPRWorktreesSpy.mockReset();
+    generateWorktreePathSpy.mockReset();
+    createWorktreeSpy.mockReset();
+    removeWorktreeSpy.mockReset();
+    getRepositoryRootSpy.mockReset();
+    deleteBranchSpy.mockReset();
+    useGitDataSpy.mockImplementation(originalUseGitData);
+    useScreenStateSpy.mockImplementation(originalUseScreenState);
+    worktreeManagerScreenSpy.mockImplementation(originalWorktreeManagerScreen as any);
+    branchCreatorScreenSpy.mockImplementation(originalBranchCreatorScreen as any);
+    branchListScreenSpy.mockImplementation(originalBranchListScreen as any);
+    getMergedPRWorktreesSpy.mockImplementation(originalGetMergedPRWorktrees as any);
+    generateWorktreePathSpy.mockImplementation(originalGenerateWorktreePath as any);
+    createWorktreeSpy.mockImplementation(originalCreateWorktree as any);
+    removeWorktreeSpy.mockImplementation(originalRemoveWorktree as any);
+    getRepositoryRootSpy.mockImplementation(originalGetRepositoryRoot as any);
+    deleteBranchSpy.mockImplementation(originalDeleteBranch as any);
+  });
+
+  it('navigates to AI tool selector when worktree is selected', () => {
+    const onExit = vi.fn();
+    render(<App onExit={onExit} />);
+
+    expect(worktreeScreenProps).not.toHaveLength(0);
+    const { onSelect, worktrees } = worktreeScreenProps[0];
+    expect(worktrees).toHaveLength(1);
+
+    onSelect(worktrees[0]);
+
+    expect(navigateToMock).toHaveBeenCalledWith('ai-tool-selector');
+  });
+
+  it('creates new worktree when branch creator submits', async () => {
+    const onExit = vi.fn();
+
+    // Update screen state mock to branch-creator for this test
+    useScreenStateSpy.mockReturnValue({
+      currentScreen: 'branch-creator',
+      navigateTo: navigateToMock as _Mock,
+      goBack: goBackMock as _Mock,
+      reset: resetMock as _Mock,
+    });
+
+    render(<App onExit={onExit} />);
+
+    expect(branchCreatorProps).not.toHaveLength(0);
+    const { onCreate } = branchCreatorProps[0];
+
+    await act(async () => {
+      await onCreate('feature/new-branch');
+    });
+
+    expect(createWorktreeSpy).toHaveBeenCalledWith(
+      expect.objectContaining({
+        branchName: 'feature/new-branch',
+        isNewBranch: true,
+      })
+    );
+    expect(navigateToMock).toHaveBeenCalledWith('ai-tool-selector');
+  });
+
+  it('displays per-branch cleanup indicators and waits before clearing results', async () => {
+    vi.useFakeTimers();
+
+    try {
+      const onExit = vi.fn();
+
+      let resolveRemoveWorktree: (() => void) | undefined;
+      let resolveDeleteBranch: (() => void) | undefined;
+
+      removeWorktreeSpy.mockImplementationOnce(
+        () =>
+          new Promise<void>((resolve) => {
+            resolveRemoveWorktree = resolve;
+          })
+      );
+
+      deleteBranchSpy.mockImplementationOnce(
+        () =>
+          new Promise<void>((resolve) => {
+            resolveDeleteBranch = resolve;
+          })
+      );
+
+      useScreenStateSpy.mockReturnValue({
+        currentScreen: 'branch-list',
+        navigateTo: navigateToMock as _Mock,
+        goBack: goBackMock as _Mock,
+        reset: resetMock as _Mock,
+      });
+
+      render(<App onExit={onExit} />);
+
+      expect(branchListProps).not.toHaveLength(0);
+      const initialProps = branchListProps.at(-1);
+      expect(initialProps).toBeDefined();
+      if (!initialProps) {
+        throw new Error('BranchListScreen props missing');
+      }
+
+      act(() => {
+        initialProps.onCleanupCommand?.();
+      });
+
+      await act(async () => {
+        await Promise.resolve();
+      });
+
+      let latestProps = branchListProps.at(-1);
+      expect(latestProps?.cleanupUI?.inputLocked).toBe(true);
+      expect(latestProps?.cleanupUI?.footerMessage?.text).toBeTruthy();
+      expect(latestProps?.cleanupUI?.indicators).toMatchObject({
+        'feature/add-new-feature': expect.objectContaining({ icon: expect.stringMatching(/⠋|⠙|⠹|⠸|⠼|⠴|⠦|⠧/) }),
+        'hotfix/urgent-fix': expect.objectContaining({ icon: '⏳' }),
+      });
+
+      resolveRemoveWorktree?.();
+
+      await act(async () => {
+        await Promise.resolve();
+      });
+
+      resolveDeleteBranch?.();
+
+      expect(removeWorktreeSpy).toHaveBeenCalledWith(
+        '/worktrees/feature-add-new-feature',
+        true
+      );
+      expect(deleteBranchSpy).toHaveBeenCalledWith('feature/add-new-feature', true);
+
+      // Flush state updates after processing first target
+      await act(async () => {
+        await Promise.resolve();
+      });
+
+      latestProps = branchListProps.at(-1);
+      expect(latestProps?.cleanupUI?.indicators).toMatchObject({
+        'feature/add-new-feature': { icon: '✅' },
+        'hotfix/urgent-fix': { icon: '⏭️' },
+      });
+      expect(latestProps?.cleanupUI?.inputLocked).toBe(false);
+
+      // Advance 3 seconds to allow UI to clear
+      await act(async () => {
+        vi.advanceTimersByTime(3000);
+        await Promise.resolve();
+      });
+
+      latestProps = branchListProps.at(-1);
+      expect(latestProps?.cleanupUI?.indicators).toEqual({});
+      expect(latestProps?.cleanupUI?.inputLocked).toBe(false);
+      expect(latestProps?.branches?.some((branch: BranchItem) => branch.name === 'feature/add-new-feature')).toBe(false);
+    } finally {
+      vi.useRealTimers();
+    }
+  });
+});
+
+afterAll(() => {
+  useGitDataSpy.mockRestore();
+  useScreenStateSpy.mockRestore();
+  worktreeManagerScreenSpy.mockRestore();
+  branchCreatorScreenSpy.mockRestore();
+    branchListScreenSpy.mockRestore();
+  getMergedPRWorktreesSpy.mockRestore();
+  generateWorktreePathSpy.mockRestore();
+  createWorktreeSpy.mockRestore();
+  removeWorktreeSpy.mockRestore();
+  getRepositoryRootSpy.mockRestore();
+  deleteBranchSpy.mockRestore();
+});

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

@@ -0,0 +1,270 @@
+/**
+ * @vitest-environment happy-dom
+ */
+import { describe, it, expect, beforeEach, afterEach, afterAll, vi } from 'vitest';
+import { act, render } from '@testing-library/react';
+import React from 'react';
+import { App } from '../../components/App.js';
+import { Window } from 'happy-dom';
+import type { BranchInfo } from '../../types.js';
+import * as useGitDataModule from '../../hooks/useGitData.js';
+
+const mockRefresh = vi.fn();
+const originalUseGitData = useGitDataModule.useGitData;
+const useGitDataSpy = vi.spyOn(useGitDataModule, 'useGitData');
+
+describe('App', () => {
+  beforeEach(() => {
+    // Setup happy-dom
+    const window = new Window();
+    globalThis.window = window as any;
+    globalThis.document = window.document as any;
+
+    vi.clearAllMocks();
+    useGitDataSpy.mockReset();
+    useGitDataSpy.mockImplementation(originalUseGitData);
+  });
+
+  const mockBranches: BranchInfo[] = [
+    {
+      name: 'main',
+      type: 'local',
+      branchType: 'main',
+      isCurrent: true,
+    },
+    {
+      name: 'feature/test',
+      type: 'local',
+      branchType: 'feature',
+      isCurrent: false,
+    },
+  ];
+
+  it('should render BranchListScreen when data is loaded', () => {
+    useGitDataSpy.mockReturnValue({
+      branches: mockBranches,
+      loading: false,
+      error: null,
+      worktrees: [],
+      refresh: mockRefresh,
+    });
+
+    const onExit = vi.fn();
+    const { getByText } = render(<App onExit={onExit} />);
+
+    // Check for BranchListScreen elements
+    expect(getByText(/gwt - Branch Selection/i)).toBeDefined();
+    expect(getByText(/main/)).toBeDefined();
+    expect(getByText(/feature\/test/)).toBeDefined();
+  });
+
+  it('should show loading state initially', async () => {
+    useGitDataSpy.mockReturnValue({
+      branches: [],
+      loading: true,
+      error: null,
+      worktrees: [],
+      refresh: mockRefresh,
+    });
+
+    const onExit = vi.fn();
+    const { queryByText, getByText } = render(
+      <App onExit={onExit} loadingIndicatorDelay={10} />
+    );
+
+    expect(queryByText(/Loading Git information/i)).toBeNull();
+
+    await act(async () => {
+      await new Promise((resolve) => setTimeout(resolve, 15));
+    });
+
+    expect(getByText(/Loading Git information/i)).toBeDefined();
+  });
+
+  it('should show error state when Git data fails to load', () => {
+    const error = new Error('Failed to fetch branches');
+    useGitDataSpy.mockReturnValue({
+      branches: [],
+      loading: false,
+      error,
+      worktrees: [],
+      refresh: mockRefresh,
+    });
+
+    const onExit = vi.fn();
+    const { getByText } = render(<App onExit={onExit} />);
+
+    expect(getByText(/Error:/i)).toBeDefined();
+    expect(getByText(/Failed to fetch branches/i)).toBeDefined();
+  });
+
+  it('should calculate statistics from branches', () => {
+    const branchesWithWorktree: BranchInfo[] = [
+      {
+        name: 'main',
+        type: 'local',
+        branchType: 'main',
+        isCurrent: true,
+      },
+      {
+        name: 'feature/a',
+        type: 'local',
+        branchType: 'feature',
+        isCurrent: false,
+        worktree: {
+          path: '/path/a',
+          locked: false,
+          prunable: false,
+        },
+      },
+      {
+        name: 'origin/main',
+        type: 'remote',
+        branchType: 'main',
+        isCurrent: false,
+      },
+    ];
+
+    useGitDataSpy.mockReturnValue({
+      branches: branchesWithWorktree,
+      loading: false,
+      error: null,
+      worktrees: [],
+      refresh: mockRefresh,
+    });
+
+    const onExit = vi.fn();
+    const { getByText, getAllByText } = render(<App onExit={onExit} />);
+
+    // Check for statistics
+    expect(getByText(/Local:/)).toBeDefined();
+    expect(getAllByText(/2/).length).toBeGreaterThan(0); // 2 local branches
+    expect(getByText(/Remote:/)).toBeDefined();
+    expect(getAllByText(/1/).length).toBeGreaterThan(0); // 1 remote branch + 1 worktree
+    expect(getByText(/Worktrees:/)).toBeDefined();
+  });
+
+  it('should call onExit when branch is selected', () => {
+    useGitDataSpy.mockReturnValue({
+      branches: mockBranches,
+      loading: false,
+      error: null,
+      worktrees: [],
+      refresh: mockRefresh,
+    });
+
+    const onExit = vi.fn();
+    const { container } = render(<App onExit={onExit} />);
+
+    expect(container).toBeDefined();
+    // Note: Testing actual selection requires simulating user input,
+    // which is covered in integration tests
+  });
+
+  it('should handle empty branch list', () => {
+    useGitDataSpy.mockReturnValue({
+      branches: [],
+      loading: false,
+      error: null,
+      worktrees: [],
+      refresh: mockRefresh,
+    });
+
+    const onExit = vi.fn();
+    const { getByText } = render(<App onExit={onExit} />);
+
+    expect(getByText(/No branches found/i)).toBeDefined();
+  });
+
+  it('should wrap with ErrorBoundary', () => {
+    // This test verifies ErrorBoundary is present
+    // Actual error catching is tested separately
+    useGitDataSpy.mockReturnValue({
+      branches: mockBranches,
+      loading: false,
+      error: null,
+      worktrees: [],
+      refresh: mockRefresh,
+    });
+
+    const onExit = vi.fn();
+    const { container } = render(<App onExit={onExit} />);
+
+    expect(container).toBeDefined();
+  });
+
+  it('should format branch items with icons', () => {
+    useGitDataSpy.mockReturnValue({
+      branches: mockBranches,
+      loading: false,
+      error: null,
+      worktrees: [],
+      refresh: mockRefresh,
+    });
+
+    const onExit = vi.fn();
+    const { getByText } = render(<App onExit={onExit} />);
+
+    // Check for branch type icon (main = ⚡)
+    expect(getByText(/⚡/)).toBeDefined();
+  });
+
+  describe('BranchActionSelectorScreen integration', () => {
+    it('should show BranchActionSelectorScreen after branch selection', () => {
+      useGitDataSpy.mockReturnValue({
+        branches: mockBranches,
+        loading: false,
+        error: null,
+        worktrees: [],
+        refresh: mockRefresh,
+      });
+
+      const onExit = vi.fn();
+      const { container } = render(<App onExit={onExit} />);
+
+      // After implementation, should verify BranchActionSelectorScreen appears
+      expect(container).toBeDefined();
+    });
+
+    it('should navigate to AI tool selector when "use existing" is selected', () => {
+      useGitDataSpy.mockReturnValue({
+        branches: mockBranches,
+        loading: false,
+        error: null,
+        worktrees: [],
+        refresh: mockRefresh,
+      });
+
+      const onExit = vi.fn();
+      const { container } = render(<App onExit={onExit} />);
+
+      // After implementation, should verify navigation to AIToolSelectorScreen
+      expect(container).toBeDefined();
+    });
+
+    it('should navigate to branch creator when "create new" is selected', () => {
+      useGitDataSpy.mockReturnValue({
+        branches: mockBranches,
+        loading: false,
+        error: null,
+        worktrees: [],
+        refresh: mockRefresh,
+      });
+
+      const onExit = vi.fn();
+      const { container } = render(<App onExit={onExit} />);
+
+      // After implementation, should verify navigation to BranchCreatorScreen
+      expect(container).toBeDefined();
+    });
+  });
+
+  afterEach(() => {
+    useGitDataSpy.mockReset();
+    useGitDataSpy.mockImplementation(originalUseGitData);
+  });
+});
+
+afterAll(() => {
+  useGitDataSpy.mockRestore();
+});

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

@@ -0,0 +1,66 @@
+/**
+ * @vitest-environment happy-dom
+ */
+import { describe, it, expect, beforeEach, vi } from 'vitest';
+import { render } from '@testing-library/react';
+import React from 'react';
+import { Confirm } from '../../../components/common/Confirm.js';
+import { Window } from 'happy-dom';
+
+describe('Confirm', () => {
+  beforeEach(() => {
+    // Setup happy-dom
+    const window = new Window();
+    globalThis.window = window as any;
+    globalThis.document = window.document as any;
+  });
+
+  it('should render the message', () => {
+    const onConfirm = vi.fn();
+    const { getByText } = render(<Confirm message="Are you sure?" onConfirm={onConfirm} />);
+
+    expect(getByText('Are you sure?')).toBeDefined();
+  });
+
+  it('should render Yes and No options', () => {
+    const onConfirm = vi.fn();
+    const { getByText } = render(<Confirm message="Continue?" onConfirm={onConfirm} />);
+
+    expect(getByText('Yes')).toBeDefined();
+    expect(getByText('No')).toBeDefined();
+  });
+
+  it('should render custom Yes and No labels', () => {
+    const onConfirm = vi.fn();
+    const { getByText } = render(
+      <Confirm message="Delete?" onConfirm={onConfirm} yesLabel="Confirm" noLabel="Cancel" />
+    );
+
+    expect(getByText('Confirm')).toBeDefined();
+    expect(getByText('Cancel')).toBeDefined();
+  });
+
+  it('should default to Yes option', () => {
+    const onConfirm = vi.fn();
+    const { container } = render(<Confirm message="Continue?" onConfirm={onConfirm} />);
+
+    // Verify component renders without error
+    expect(container).toBeDefined();
+  });
+
+  it('should accept defaultNo prop to default to No', () => {
+    const onConfirm = vi.fn();
+    const { container } = render(<Confirm message="Continue?" onConfirm={onConfirm} defaultNo />);
+
+    expect(container).toBeDefined();
+  });
+
+  it('should call onConfirm with false by default when rendered', () => {
+    const onConfirm = vi.fn();
+    render(<Confirm message="Continue?" onConfirm={onConfirm} />);
+
+    // Note: Simulating selection requires ink-testing-library
+    // For now, we just verify the component structure
+    expect(onConfirm).not.toHaveBeenCalled();
+  });
+});