ccmanager 3.9.0 → 3.10.0

package/dist/components/Dashboard.test.js

@@ -0,0 +1,348 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+import { render } from 'ink-testing-library';
+import { describe, it, expect, vi, beforeEach } from 'vitest';
+// Mock bunTerminal to avoid native module loading issues
+vi.mock('../services/bunTerminal.js', () => ({
+    spawn: vi.fn(function () {
+        return null;
+    }),
+}));
+// Import the actual component code but skip the useInput hook
+vi.mock('ink', async () => {
+    const actual = await vi.importActual('ink');
+    return {
+        ...actual,
+        useInput: vi.fn(),
+    };
+});
+// Mock SelectInput to render items as simple text
+vi.mock('ink-select-input', async () => {
+    const React = await vi.importActual('react');
+    const { Text, Box } = await vi.importActual('ink');
+    return {
+        default: ({ items }) => {
+            return React.createElement(Box, { flexDirection: 'column' }, items.map((item, index) => React.createElement(Text, { key: index }, item.label)));
+        },
+    };
+});
+// Mock TextInputWrapper to render as simple text
+vi.mock('./TextInputWrapper.js', async () => {
+    const React = await vi.importActual('react');
+    const { Text } = await vi.importActual('ink');
+    return {
+        default: ({ value, placeholder }) => {
+            return React.createElement(Text, {}, value || placeholder || '');
+        },
+    };
+});
+// Mock Effect for testing
+vi.mock('effect', async () => {
+    const actual = await vi.importActual('effect');
+    return actual;
+});
+// Mock the projectManager
+vi.mock('../services/projectManager.js', () => ({
+    projectManager: {
+        instance: {
+            discoverProjectsEffect: vi.fn(),
+        },
+        getRecentProjects: vi.fn().mockReturnValue([]),
+    },
+}));
+// Mock globalSessionOrchestrator
+vi.mock('../services/globalSessionOrchestrator.js', () => ({
+    globalSessionOrchestrator: {
+        getProjectPaths: vi.fn().mockReturnValue([]),
+        getProjectSessions: vi.fn().mockReturnValue([]),
+        getManagerForProject: vi.fn().mockReturnValue({
+            on: vi.fn(),
+            off: vi.fn(),
+            getAllSessions: vi.fn().mockReturnValue([]),
+        }),
+    },
+}));
+// Mock WorktreeService
+vi.mock('../services/worktreeService.js', () => ({
+    WorktreeService: vi.fn().mockImplementation(() => ({
+        getWorktreesEffect: vi.fn(),
+        getGitRootPath: vi.fn().mockReturnValue('/test'),
+    })),
+}));
+// Mock useGitStatus to avoid async polling in tests
+vi.mock('../hooks/useGitStatus.js', () => ({
+    useGitStatus: vi.fn((worktrees) => worktrees),
+}));
+// Mock SessionManager static methods
+vi.mock('../services/sessionManager.js', () => ({
+    SessionManager: {
+        getSessionCounts: vi.fn().mockReturnValue({
+            idle: 0,
+            busy: 0,
+            waiting_input: 0,
+            pending_auto_approval: 0,
+            total: 0,
+            backgroundTasks: 0,
+            teamMembers: 0,
+        }),
+        formatSessionCounts: vi.fn().mockReturnValue(''),
+    },
+}));
+// Now import after mocking
+const { default: Dashboard } = await import('./Dashboard.js');
+const { projectManager } = await import('../services/projectManager.js');
+const { globalSessionOrchestrator } = await import('../services/globalSessionOrchestrator.js');
+const { SessionManager } = await import('../services/sessionManager.js');
+const { WorktreeService } = await import('../services/worktreeService.js');
+const { Effect } = await import('effect');
+describe('Dashboard', () => {
+    const mockOnSelectSession = vi.fn();
+    const mockOnSelectProject = vi.fn();
+    const mockOnDismissError = vi.fn();
+    const mockProjects = [
+        {
+            name: 'my-app',
+            path: '/projects/my-app',
+            relativePath: 'my-app',
+            isValid: true,
+        },
+        {
+            name: 'api-server',
+            path: '/projects/api-server',
+            relativePath: 'api-server',
+            isValid: true,
+        },
+        {
+            name: 'shared-lib',
+            path: '/projects/shared-lib',
+            relativePath: 'shared-lib',
+            isValid: true,
+        },
+    ];
+    beforeEach(() => {
+        vi.clearAllMocks();
+        vi.mocked(projectManager.instance.discoverProjectsEffect).mockReturnValue(Effect.succeed(mockProjects));
+        vi.mocked(globalSessionOrchestrator.getProjectPaths).mockReturnValue([]);
+        vi.mocked(globalSessionOrchestrator.getProjectSessions).mockReturnValue([]);
+        vi.mocked(globalSessionOrchestrator.getManagerForProject).mockReturnValue({
+            on: vi.fn(),
+            off: vi.fn(),
+            getAllSessions: vi.fn().mockReturnValue([]),
+        });
+    });
+    it('should render dashboard with correct title and version', () => {
+        const { lastFrame } = render(_jsx(Dashboard, { projectsDir: "/projects", onSelectSession: mockOnSelectSession, onSelectProject: mockOnSelectProject, error: null, onDismissError: mockOnDismissError, version: "3.8.1" }));
+        expect(lastFrame()).toContain('CCManager - Dashboard v3.8.1');
+    });
+    it('should display loading state initially', () => {
+        vi.mocked(projectManager.instance.discoverProjectsEffect).mockReturnValue(Effect.async(() => { }));
+        const { lastFrame } = render(_jsx(Dashboard, { projectsDir: "/projects", onSelectSession: mockOnSelectSession, onSelectProject: mockOnSelectProject, error: null, onDismissError: mockOnDismissError, version: "3.8.1" }));
+        expect(lastFrame()).toContain('Discovering projects...');
+    });
+    it('should display projects after loading', async () => {
+        const { lastFrame, rerender } = render(_jsx(Dashboard, { projectsDir: "/projects", onSelectSession: mockOnSelectSession, onSelectProject: mockOnSelectProject, error: null, onDismissError: mockOnDismissError, version: "3.8.1" }));
+        await new Promise(resolve => setTimeout(resolve, 100));
+        rerender(_jsx(Dashboard, { projectsDir: "/projects", onSelectSession: mockOnSelectSession, onSelectProject: mockOnSelectProject, error: null, onDismissError: mockOnDismissError, version: "3.8.1" }));
+        await vi.waitFor(() => {
+            const frame = lastFrame();
+            return frame && !frame.includes('Discovering projects...');
+        }, { timeout: 2000 });
+        const frame = lastFrame();
+        expect(frame).toContain('my-app');
+        expect(frame).toContain('api-server');
+        expect(frame).toContain('shared-lib');
+    });
+    it('should display Projects section separator', async () => {
+        const { lastFrame, rerender } = render(_jsx(Dashboard, { projectsDir: "/projects", onSelectSession: mockOnSelectSession, onSelectProject: mockOnSelectProject, error: null, onDismissError: mockOnDismissError, version: "3.8.1" }));
+        await new Promise(resolve => setTimeout(resolve, 100));
+        rerender(_jsx(Dashboard, { projectsDir: "/projects", onSelectSession: mockOnSelectSession, onSelectProject: mockOnSelectProject, error: null, onDismissError: mockOnDismissError, version: "3.8.1" }));
+        await vi.waitFor(() => {
+            return lastFrame()?.includes('my-app') ?? false;
+        });
+        expect(lastFrame()).toContain('Projects');
+    });
+    it('should display Other section with Refresh and Exit', async () => {
+        const { lastFrame, rerender } = render(_jsx(Dashboard, { projectsDir: "/projects", onSelectSession: mockOnSelectSession, onSelectProject: mockOnSelectProject, error: null, onDismissError: mockOnDismissError, version: "3.8.1" }));
+        await new Promise(resolve => setTimeout(resolve, 100));
+        rerender(_jsx(Dashboard, { projectsDir: "/projects", onSelectSession: mockOnSelectSession, onSelectProject: mockOnSelectProject, error: null, onDismissError: mockOnDismissError, version: "3.8.1" }));
+        await vi.waitFor(() => {
+            return lastFrame()?.includes('my-app') ?? false;
+        });
+        const frame = lastFrame();
+        expect(frame).toContain('Other');
+        expect(frame).toContain('Refresh');
+        expect(frame).toContain('Exit');
+    });
+    it('should display number shortcuts for projects', async () => {
+        const { lastFrame, rerender } = render(_jsx(Dashboard, { projectsDir: "/projects", onSelectSession: mockOnSelectSession, onSelectProject: mockOnSelectProject, error: null, onDismissError: mockOnDismissError, version: "3.8.1" }));
+        await new Promise(resolve => setTimeout(resolve, 100));
+        rerender(_jsx(Dashboard, { projectsDir: "/projects", onSelectSession: mockOnSelectSession, onSelectProject: mockOnSelectProject, error: null, onDismissError: mockOnDismissError, version: "3.8.1" }));
+        await vi.waitFor(() => {
+            return lastFrame()?.includes('my-app') ?? false;
+        });
+        const frame = lastFrame();
+        expect(frame).toContain('0 ❯ my-app');
+        expect(frame).toContain('1 ❯ api-server');
+        expect(frame).toContain('2 ❯ shared-lib');
+    });
+    it('should display status legend', () => {
+        const { lastFrame } = render(_jsx(Dashboard, { projectsDir: "/projects", onSelectSession: mockOnSelectSession, onSelectProject: mockOnSelectProject, error: null, onDismissError: mockOnDismissError, version: "3.8.1" }));
+        const frame = lastFrame();
+        expect(frame).toContain('Busy');
+        expect(frame).toContain('Waiting');
+        expect(frame).toContain('Idle');
+    });
+    it('should display error when provided', () => {
+        const { lastFrame } = render(_jsx(Dashboard, { projectsDir: "/projects", onSelectSession: mockOnSelectSession, onSelectProject: mockOnSelectProject, error: "Failed to load", onDismissError: mockOnDismissError, version: "3.8.1" }));
+        expect(lastFrame()).toContain('Error: Failed to load');
+        expect(lastFrame()).toContain('Press any key to dismiss');
+    });
+    it('should show empty state when no projects found', async () => {
+        vi.mocked(projectManager.instance.discoverProjectsEffect).mockReturnValue(Effect.succeed([]));
+        const { lastFrame, rerender } = render(_jsx(Dashboard, { projectsDir: "/projects", onSelectSession: mockOnSelectSession, onSelectProject: mockOnSelectProject, error: null, onDismissError: mockOnDismissError, version: "3.8.1" }));
+        await new Promise(resolve => setTimeout(resolve, 100));
+        rerender(_jsx(Dashboard, { projectsDir: "/projects", onSelectSession: mockOnSelectSession, onSelectProject: mockOnSelectProject, error: null, onDismissError: mockOnDismissError, version: "3.8.1" }));
+        await vi.waitFor(() => {
+            const frame = lastFrame();
+            return frame && !frame.includes('Discovering projects...');
+        }, { timeout: 2000 });
+        expect(lastFrame()).toContain('No git repositories found in /projects');
+    });
+    it('should not show Active Sessions section when there are no sessions', async () => {
+        const { lastFrame, rerender } = render(_jsx(Dashboard, { projectsDir: "/projects", onSelectSession: mockOnSelectSession, onSelectProject: mockOnSelectProject, error: null, onDismissError: mockOnDismissError, version: "3.8.1" }));
+        await new Promise(resolve => setTimeout(resolve, 100));
+        rerender(_jsx(Dashboard, { projectsDir: "/projects", onSelectSession: mockOnSelectSession, onSelectProject: mockOnSelectProject, error: null, onDismissError: mockOnDismissError, version: "3.8.1" }));
+        await vi.waitFor(() => {
+            return lastFrame()?.includes('my-app') ?? false;
+        });
+        expect(lastFrame()).not.toContain('Active Sessions');
+    });
+    it('should show Active Sessions when sessions exist', async () => {
+        const mockSession = {
+            id: 'session-1',
+            worktreePath: '/projects/my-app/worktrees/feature-auth',
+            lastActivity: new Date(),
+            isActive: true,
+            stateMutex: {
+                getSnapshot: () => ({
+                    state: 'busy',
+                    backgroundTaskCount: 0,
+                    teamMemberCount: 0,
+                }),
+            },
+        };
+        const mockWorktrees = [
+            {
+                path: '/projects/my-app/worktrees/feature-auth',
+                branch: 'feature/auth',
+                isMainWorktree: false,
+                hasSession: true,
+            },
+        ];
+        vi.mocked(globalSessionOrchestrator.getProjectPaths).mockReturnValue([
+            '/projects/my-app',
+        ]);
+        vi.mocked(globalSessionOrchestrator.getProjectSessions).mockReturnValue([
+            mockSession,
+        ]);
+        vi.mocked(WorktreeService).mockImplementation(function () {
+            return {
+                getWorktreesEffect: () => Effect.succeed(mockWorktrees),
+                getGitRootPath: () => '/projects/my-app',
+            };
+        });
+        const { lastFrame, rerender } = render(_jsx(Dashboard, { projectsDir: "/projects", onSelectSession: mockOnSelectSession, onSelectProject: mockOnSelectProject, error: null, onDismissError: mockOnDismissError, version: "3.8.1" }));
+        await new Promise(resolve => setTimeout(resolve, 200));
+        rerender(_jsx(Dashboard, { projectsDir: "/projects", onSelectSession: mockOnSelectSession, onSelectProject: mockOnSelectProject, error: null, onDismissError: mockOnDismissError, version: "3.8.1" }));
+        await vi.waitFor(() => {
+            const frame = lastFrame();
+            return frame?.includes('Active Sessions') ?? false;
+        }, { timeout: 3000 });
+        const frame = lastFrame();
+        expect(frame).toContain('Active Sessions');
+        expect(frame).toContain('my-app :: feature/auth');
+        expect(frame).toContain('Busy');
+    });
+    it('should show session counts next to projects', async () => {
+        vi.mocked(SessionManager.formatSessionCounts).mockReturnValue(' (1 Busy)');
+        vi.mocked(globalSessionOrchestrator.getProjectSessions).mockImplementation((path) => {
+            if (path === '/projects/my-app') {
+                return [{ id: 'session-1' }];
+            }
+            return [];
+        });
+        const { lastFrame, rerender } = render(_jsx(Dashboard, { projectsDir: "/projects", onSelectSession: mockOnSelectSession, onSelectProject: mockOnSelectProject, error: null, onDismissError: mockOnDismissError, version: "3.8.1" }));
+        await new Promise(resolve => setTimeout(resolve, 100));
+        rerender(_jsx(Dashboard, { projectsDir: "/projects", onSelectSession: mockOnSelectSession, onSelectProject: mockOnSelectProject, error: null, onDismissError: mockOnDismissError, version: "3.8.1" }));
+        await vi.waitFor(() => {
+            return lastFrame()?.includes('my-app') ?? false;
+        });
+        expect(lastFrame()).toContain('(1 Busy)');
+    });
+    it('should use relativePath for duplicate project names', async () => {
+        const duplicateProjects = [
+            {
+                name: 'utils',
+                path: '/projects/team-a/utils',
+                relativePath: 'team-a/utils',
+                isValid: true,
+            },
+            {
+                name: 'utils',
+                path: '/projects/team-b/utils',
+                relativePath: 'team-b/utils',
+                isValid: true,
+            },
+        ];
+        vi.mocked(projectManager.instance.discoverProjectsEffect).mockReturnValue(Effect.succeed(duplicateProjects));
+        const { lastFrame, rerender } = render(_jsx(Dashboard, { projectsDir: "/projects", onSelectSession: mockOnSelectSession, onSelectProject: mockOnSelectProject, error: null, onDismissError: mockOnDismissError, version: "3.8.1" }));
+        await new Promise(resolve => setTimeout(resolve, 100));
+        rerender(_jsx(Dashboard, { projectsDir: "/projects", onSelectSession: mockOnSelectSession, onSelectProject: mockOnSelectProject, error: null, onDismissError: mockOnDismissError, version: "3.8.1" }));
+        await vi.waitFor(() => {
+            return lastFrame()?.includes('team-a/utils') ?? false;
+        });
+        const frame = lastFrame();
+        expect(frame).toContain('team-a/utils');
+        expect(frame).toContain('team-b/utils');
+    });
+    it('should display controls help text', () => {
+        const { lastFrame } = render(_jsx(Dashboard, { projectsDir: "/projects", onSelectSession: mockOnSelectSession, onSelectProject: mockOnSelectProject, error: null, onDismissError: mockOnDismissError, version: "3.8.1" }));
+        expect(lastFrame()).toContain('Controls:');
+        expect(lastFrame()).toContain('0-9 Quick Select');
+        expect(lastFrame()).toContain('R-Refresh');
+        expect(lastFrame()).toContain('Q-Quit');
+    });
+    it('should handle filesystem error during project discovery', async () => {
+        const { FileSystemError } = await import('../types/errors.js');
+        vi.mocked(projectManager.instance.discoverProjectsEffect).mockReturnValue(Effect.fail(new FileSystemError({
+            operation: 'read',
+            path: '/projects',
+            cause: 'Permission denied',
+        })));
+        const { lastFrame, rerender } = render(_jsx(Dashboard, { projectsDir: "/projects", onSelectSession: mockOnSelectSession, onSelectProject: mockOnSelectProject, error: null, onDismissError: mockOnDismissError, version: "3.8.1" }));
+        await new Promise(resolve => setTimeout(resolve, 100));
+        rerender(_jsx(Dashboard, { projectsDir: "/projects", onSelectSession: mockOnSelectSession, onSelectProject: mockOnSelectProject, error: null, onDismissError: mockOnDismissError, version: "3.8.1" }));
+        await vi.waitFor(() => {
+            const frame = lastFrame();
+            return frame && !frame.includes('Discovering projects...');
+        }, { timeout: 2000 });
+        expect(lastFrame()).toContain('Error:');
+    });
+    it('should show recent projects first in the Projects section', async () => {
+        vi.mocked(projectManager.getRecentProjects).mockReturnValue([
+            {
+                path: '/projects/shared-lib',
+                name: 'shared-lib',
+                lastAccessed: Date.now(),
+            },
+        ]);
+        const { lastFrame, rerender } = render(_jsx(Dashboard, { projectsDir: "/projects", onSelectSession: mockOnSelectSession, onSelectProject: mockOnSelectProject, error: null, onDismissError: mockOnDismissError, version: "3.8.1" }));
+        await new Promise(resolve => setTimeout(resolve, 100));
+        rerender(_jsx(Dashboard, { projectsDir: "/projects", onSelectSession: mockOnSelectSession, onSelectProject: mockOnSelectProject, error: null, onDismissError: mockOnDismissError, version: "3.8.1" }));
+        await vi.waitFor(() => {
+            return lastFrame()?.includes('shared-lib') ?? false;
+        });
+        const frame = lastFrame();
+        // shared-lib should appear first (index 0) because it's recent
+        expect(frame).toContain('0 ❯ shared-lib');
+    });
+});

package/dist/services/globalSessionOrchestrator.d.ts

@@ -10,6 +10,7 @@ declare class GlobalSessionOrchestrator {
     getAllActiveSessions(): Session[];
     destroyAllSessions(): void;
     destroyProjectSessions(projectPath: string): void;
+    getProjectPaths(): string[];
     getProjectSessions(projectPath: string): Session[];
 }
 export declare const globalSessionOrchestrator: GlobalSessionOrchestrator;

package/dist/services/globalSessionOrchestrator.js

@@ -53,6 +53,9 @@ class GlobalSessionOrchestrator {
             this.projectManagers.delete(projectPath);
         }
     }
+    getProjectPaths() {
+        return Array.from(this.projectManagers.keys());
+    }
     getProjectSessions(projectPath) {
         const manager = this.projectManagers.get(projectPath);
         if (manager) {

package/dist/services/projectManager.d.ts

@@ -32,9 +32,15 @@ export declare class ProjectManager implements IProjectManager {
      */
     private discoverDirectories;
     /**
-     * Quick check for .git directory without running git commands
+     * Quick check for .git presence (directory or file) without running git commands.
+     * Returns true for both main repositories and worktrees.
      */
     private hasGitDirectory;
+    /**
+     * Check if a directory is a main git repository (not a worktree).
+     * Main repositories have .git as a directory; worktrees have .git as a file.
+     */
+    private isMainGitRepository;
     /**
      * Process directories in parallel using worker pool pattern
      */

package/dist/services/projectManager.js

@@ -167,12 +167,15 @@ export class ProjectManager {
                     // Quick check if this is a git repository
                     const hasGitDir = await this.hasGitDirectory(fullPath);
                     if (hasGitDir) {
-                        // Found a git repository - add to tasks and skip subdirectories
-                        if (!seen.has(fullPath)) {
+                        // Only add main repositories (.git is a directory),
+                        // not worktrees (.git is a file pointing to the main repo)
+                        const isMain = await this.isMainGitRepository(fullPath);
+                        if (isMain && !seen.has(fullPath)) {
                             seen.add(fullPath);
                             tasks.push({ path: fullPath, relativePath });
                         }
-                        return; // Early termination - don't walk subdirectories
+                        // Early termination for any git-related dir
+                        return;
                     }
                     // Not a git repo, continue walking subdirectories
                     await walk(fullPath, depth + 1);
@@ -189,13 +192,28 @@ export class ProjectManager {
         return tasks;
     }
     /**
-     * Quick check for .git directory without running git commands
+     * Quick check for .git presence (directory or file) without running git commands.
+     * Returns true for both main repositories and worktrees.
      */
     async hasGitDirectory(dirPath) {
         try {
             const gitPath = path.join(dirPath, '.git');
             const stats = await fs.stat(gitPath);
-            return stats.isDirectory() || stats.isFile(); // File for worktrees
+            return stats.isDirectory() || stats.isFile();
+        }
+        catch {
+            return false;
+        }
+    }
+    /**
+     * Check if a directory is a main git repository (not a worktree).
+     * Main repositories have .git as a directory; worktrees have .git as a file.
+     */
+    async isMainGitRepository(dirPath) {
+        try {
+            const gitPath = path.join(dirPath, '.git');
+            const stats = await fs.stat(gitPath);
+            return stats.isDirectory();
         }
         catch {
             return false;
@@ -242,11 +260,9 @@ export class ProjectManager {
             name: path.basename(task.path),
         };
         try {
-            // Check if directory has .git (already validated in discoverDirectories)
-            // Double-check here to ensure it's still valid
-            const hasGit = await this.hasGitDirectory(task.path);
-            if (!hasGit) {
-                // Not a git repo, return null to filter it out
+            // Double-check here to ensure it's still a valid main repository
+            const isMain = await this.isMainGitRepository(task.path);
+            if (!isMain) {
                 return null;
             }
         }

package/dist/utils/worktreeUtils.d.ts

@@ -2,7 +2,7 @@ import { Worktree, Session } from '../types/index.js';
 /**
  * Worktree item with formatted content for display.
  */
-interface WorktreeItem {
+export interface WorktreeItem {
     worktree: Worktree;
     session?: Session;
     baseLabel: string;
@@ -39,4 +39,3 @@ export declare function calculateColumnPositions(items: WorktreeItem[]): {
  * Assembles the final worktree label with proper column alignment
  */
 export declare function assembleWorktreeLabel(item: WorktreeItem, columns: ReturnType<typeof calculateColumnPositions>): string;
-export {};

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "ccmanager",
-	"version": "3.9.0",
+	"version": "3.10.0",
 	"description": "TUI application for managing multiple Claude Code sessions across Git worktrees",
 	"license": "MIT",
 	"author": "Kodai Kabasawa",
@@ -41,11 +41,11 @@
 		"bin"
 	],
 	"optionalDependencies": {
-		"@kodaikabasawa/ccmanager-darwin-arm64": "3.9.0",
-		"@kodaikabasawa/ccmanager-darwin-x64": "3.9.0",
-		"@kodaikabasawa/ccmanager-linux-arm64": "3.9.0",
-		"@kodaikabasawa/ccmanager-linux-x64": "3.9.0",
-		"@kodaikabasawa/ccmanager-win32-x64": "3.9.0"
+		"@kodaikabasawa/ccmanager-darwin-arm64": "3.10.0",
+		"@kodaikabasawa/ccmanager-darwin-x64": "3.10.0",
+		"@kodaikabasawa/ccmanager-linux-arm64": "3.10.0",
+		"@kodaikabasawa/ccmanager-linux-x64": "3.10.0",
+		"@kodaikabasawa/ccmanager-win32-x64": "3.10.0"
 	},
 	"devDependencies": {
 		"@eslint/js": "^9.28.0",

package/dist/components/ProjectList.d.ts

@@ -1,10 +0,0 @@
-import React from 'react';
-import { GitProject } from '../types/index.js';
-interface ProjectListProps {
-    projectsDir: string;
-    onSelectProject: (project: GitProject) => void;
-    error: string | null;
-    onDismissError: () => void;
-}
-declare const ProjectList: React.FC<ProjectListProps>;
-export default ProjectList;