ccmanager 1.4.4 → 2.0.0

package/dist/components/Menu.test.js

@@ -0,0 +1,196 @@
+import React from 'react';
+import { render } from 'ink-testing-library';
+import Menu from './Menu.js';
+import { SessionManager } from '../services/sessionManager.js';
+import { WorktreeService } from '../services/worktreeService.js';
+import { vi, describe, it, expect, beforeEach, afterEach } from 'vitest';
+// Mock ink to avoid stdin issues
+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 dependencies
+vi.mock('../hooks/useGitStatus.js', () => ({
+    useGitStatus: (worktrees) => worktrees,
+}));
+vi.mock('../services/projectManager.js', () => ({
+    projectManager: {
+        getRecentProjects: vi.fn().mockReturnValue([]),
+    },
+}));
+vi.mock('../services/globalSessionOrchestrator.js', () => ({
+    globalSessionOrchestrator: {
+        getProjectSessions: vi.fn().mockReturnValue([]),
+    },
+}));
+vi.mock('../services/shortcutManager.js', () => ({
+    shortcutManager: {
+        getShortcutDisplay: vi.fn().mockReturnValue('Ctrl+C'),
+        getShortcuts: vi.fn().mockReturnValue({
+            refresh: { key: 'r' },
+            newWorktree: { key: 'n' },
+            quit: { key: 'q', ctrl: true },
+        }),
+        matchesShortcut: vi.fn().mockReturnValue(false),
+    },
+}));
+vi.mock('../hooks/useSearchMode.js', () => ({
+    useSearchMode: () => ({
+        isSearchMode: false,
+        searchQuery: '',
+        setSearchQuery: vi.fn(),
+        handleKey: vi.fn(),
+    }),
+}));
+describe('Menu component rendering', () => {
+    let sessionManager;
+    let worktreeService;
+    beforeEach(() => {
+        sessionManager = new SessionManager();
+        worktreeService = new WorktreeService();
+        vi.spyOn(worktreeService, 'getWorktrees').mockReturnValue([]);
+        vi.spyOn(sessionManager, 'getAllSessions').mockReturnValue([]);
+        // Mock EventEmitter methods
+        vi.spyOn(sessionManager, 'on').mockImplementation(() => sessionManager);
+        vi.spyOn(sessionManager, 'off').mockImplementation(() => sessionManager);
+    });
+    afterEach(() => {
+        vi.restoreAllMocks();
+    });
+    it('should not render duplicate title when re-rendered with new key', async () => {
+        const onSelectWorktree = vi.fn();
+        // First render
+        const { unmount, lastFrame } = render(React.createElement(Menu, { key: 1, sessionManager: sessionManager, worktreeService: worktreeService, onSelectWorktree: onSelectWorktree }));
+        // Wait for async operations
+        await new Promise(resolve => setTimeout(resolve, 100));
+        const firstRenderOutput = lastFrame();
+        // Count occurrences of the title
+        const titleCount = (firstRenderOutput?.match(/CCManager - Claude Code Worktree Manager/g) ||
+            []).length;
+        expect(titleCount).toBe(1);
+        // Unmount and re-render with new key
+        unmount();
+        const { lastFrame: lastFrame2 } = render(React.createElement(Menu, { key: 2, sessionManager: sessionManager, worktreeService: worktreeService, onSelectWorktree: onSelectWorktree }));
+        await new Promise(resolve => setTimeout(resolve, 100));
+        const secondRenderOutput = lastFrame2();
+        const titleCount2 = (secondRenderOutput?.match(/CCManager - Claude Code Worktree Manager/g) ||
+            []).length;
+        expect(titleCount2).toBe(1);
+    });
+    it('should render title and description only once', async () => {
+        const onSelectWorktree = vi.fn();
+        const { lastFrame } = render(React.createElement(Menu, { sessionManager: sessionManager, worktreeService: worktreeService, onSelectWorktree: onSelectWorktree }));
+        await new Promise(resolve => setTimeout(resolve, 100));
+        const output = lastFrame();
+        // Check title appears only once
+        const titleMatches = output?.match(/CCManager - Claude Code Worktree Manager/g) || [];
+        expect(titleMatches.length).toBe(1);
+        // Check description appears only once
+        const descMatches = output?.match(/Select a worktree to start or resume a Claude Code session:/g) || [];
+        expect(descMatches.length).toBe(1);
+    });
+    it('should display number shortcuts for recent projects when worktrees < 10', async () => {
+        const onSelectWorktree = vi.fn();
+        const onSelectRecentProject = vi.fn();
+        // Setup: 3 worktrees
+        const mockWorktrees = [
+            {
+                path: '/test/wt1',
+                branch: 'feature-1',
+                isMainWorktree: false,
+                hasSession: false,
+            },
+            {
+                path: '/test/wt2',
+                branch: 'feature-2',
+                isMainWorktree: false,
+                hasSession: false,
+            },
+            {
+                path: '/test/wt3',
+                branch: 'feature-3',
+                isMainWorktree: false,
+                hasSession: false,
+            },
+        ];
+        // Setup: 3 recent projects
+        const mockRecentProjects = [
+            { name: 'Project A', path: '/test/project-a', lastAccessed: Date.now() },
+            { name: 'Project B', path: '/test/project-b', lastAccessed: Date.now() },
+            { name: 'Project C', path: '/test/project-c', lastAccessed: Date.now() },
+        ];
+        vi.spyOn(worktreeService, 'getWorktrees').mockReturnValue(mockWorktrees);
+        vi.spyOn(worktreeService, 'getGitRootPath').mockReturnValue('/test/current');
+        const { projectManager } = await import('../services/projectManager.js');
+        vi.mocked(projectManager.getRecentProjects).mockReturnValue(mockRecentProjects);
+        // Mock session counts
+        vi.spyOn(SessionManager, 'getSessionCounts').mockReturnValue({
+            idle: 0,
+            busy: 0,
+            waiting_input: 0,
+            total: 0,
+        });
+        vi.spyOn(SessionManager, 'formatSessionCounts').mockReturnValue('');
+        const { lastFrame } = render(React.createElement(Menu, { sessionManager: sessionManager, worktreeService: worktreeService, onSelectWorktree: onSelectWorktree, onSelectRecentProject: onSelectRecentProject, multiProject: true }));
+        await new Promise(resolve => setTimeout(resolve, 100));
+        const output = lastFrame();
+        // Check that worktrees have numbers 0-2
+        expect(output).toContain('0 ❯');
+        expect(output).toContain('1 ❯');
+        expect(output).toContain('2 ❯');
+        // Check that recent projects have numbers 3-5
+        expect(output).toContain('3 ❯ Project A');
+        expect(output).toContain('4 ❯ Project B');
+        expect(output).toContain('5 ❯ Project C');
+    });
+    it('should not display number shortcuts for recent projects when worktrees >= 10', async () => {
+        const onSelectWorktree = vi.fn();
+        const onSelectRecentProject = vi.fn();
+        // Setup: 10 worktrees
+        const mockWorktrees = Array.from({ length: 10 }, (_, i) => ({
+            path: `/test/wt${i}`,
+            branch: `feature-${i}`,
+            isMainWorktree: false,
+            hasSession: false,
+        }));
+        // Setup: 2 recent projects
+        const mockRecentProjects = [
+            { name: 'Project A', path: '/test/project-a', lastAccessed: Date.now() },
+            { name: 'Project B', path: '/test/project-b', lastAccessed: Date.now() },
+        ];
+        vi.spyOn(worktreeService, 'getWorktrees').mockReturnValue(mockWorktrees);
+        vi.spyOn(worktreeService, 'getGitRootPath').mockReturnValue('/test/current');
+        const { projectManager } = await import('../services/projectManager.js');
+        vi.mocked(projectManager.getRecentProjects).mockReturnValue(mockRecentProjects);
+        // Mock session counts
+        vi.spyOn(SessionManager, 'getSessionCounts').mockReturnValue({
+            idle: 0,
+            busy: 0,
+            waiting_input: 0,
+            total: 0,
+        });
+        vi.spyOn(SessionManager, 'formatSessionCounts').mockReturnValue('');
+        const { lastFrame } = render(React.createElement(Menu, { sessionManager: sessionManager, worktreeService: worktreeService, onSelectWorktree: onSelectWorktree, onSelectRecentProject: onSelectRecentProject, multiProject: true }));
+        await new Promise(resolve => setTimeout(resolve, 100));
+        const output = lastFrame();
+        // Check that recent projects don't have numbers (just ❯ prefix)
+        expect(output).toContain('❯ Project A');
+        expect(output).toContain('❯ Project B');
+        // Make sure they don't have number prefixes
+        expect(output).not.toContain('10 ❯ Project A');
+        expect(output).not.toContain('11 ❯ Project B');
+    });
+});

package/dist/components/ProjectList.d.ts

@@ -0,0 +1,10 @@
+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;

package/dist/components/ProjectList.js

@@ -0,0 +1,231 @@
+import React, { useState, useEffect } from 'react';
+import { Box, Text, useInput } from 'ink';
+import SelectInput from 'ink-select-input';
+import { projectManager } from '../services/projectManager.js';
+import { MENU_ICONS } from '../constants/statusIcons.js';
+import TextInputWrapper from './TextInputWrapper.js';
+import { useSearchMode } from '../hooks/useSearchMode.js';
+import { globalSessionOrchestrator } from '../services/globalSessionOrchestrator.js';
+import { SessionManager } from '../services/sessionManager.js';
+const ProjectList = ({ projectsDir, onSelectProject, error, onDismissError, }) => {
+    const [projects, setProjects] = useState([]);
+    const [recentProjects, setRecentProjects] = useState([]);
+    const [items, setItems] = useState([]);
+    const [loading, setLoading] = useState(true);
+    const [loadError, setLoadError] = useState(null);
+    const limit = 10;
+    // Use the search mode hook
+    const displayError = error || loadError;
+    const { isSearchMode, searchQuery, selectedIndex, setSearchQuery } = useSearchMode(items.length, {
+        isDisabled: !!displayError,
+        skipInTest: false,
+    });
+    const loadProjects = async () => {
+        setLoading(true);
+        setLoadError(null);
+        try {
+            const discoveredProjects = await projectManager.instance.discoverProjects(projectsDir);
+            setProjects(discoveredProjects);
+            // Load recent projects with no limit (pass 0)
+            const allRecentProjects = projectManager.getRecentProjects(0);
+            setRecentProjects(allRecentProjects);
+        }
+        catch (err) {
+            setLoadError(err.message);
+        }
+        finally {
+            setLoading(false);
+        }
+    };
+    useEffect(() => {
+        loadProjects();
+        // eslint-disable-next-line react-hooks/exhaustive-deps
+    }, [projectsDir]);
+    useEffect(() => {
+        const menuItems = [];
+        let currentIndex = 0;
+        // Filter recent projects based on search query
+        const filteredRecentProjects = searchQuery
+            ? recentProjects.filter(project => project.name.toLowerCase().includes(searchQuery.toLowerCase()))
+            : recentProjects;
+        // Add recent projects section if available and not in search mode
+        if (filteredRecentProjects.length > 0) {
+            // Add "Recent" separator only when not in search mode
+            if (!isSearchMode) {
+                menuItems.push({
+                    label: '── Recent ──',
+                    value: 'separator-recent',
+                });
+            }
+            // Add recent projects
+            filteredRecentProjects.forEach(recentProject => {
+                // Find the full project data
+                const fullProject = projects.find(p => p.path === recentProject.path);
+                if (fullProject) {
+                    // Get session counts for this project
+                    const projectSessions = globalSessionOrchestrator.getProjectSessions(recentProject.path);
+                    const counts = SessionManager.getSessionCounts(projectSessions);
+                    const countsFormatted = SessionManager.formatSessionCounts(counts);
+                    const numberPrefix = !isSearchMode && currentIndex < 10 ? `${currentIndex} ❯ ` : '❯ ';
+                    menuItems.push({
+                        label: numberPrefix + recentProject.name + countsFormatted,
+                        value: recentProject.path,
+                        project: fullProject,
+                    });
+                    currentIndex++;
+                }
+            });
+        }
+        // Filter projects based on search query
+        const filteredProjects = searchQuery
+            ? projects.filter(project => project.name.toLowerCase().includes(searchQuery.toLowerCase()))
+            : projects;
+        // Filter out recent projects from all projects to avoid duplicates
+        const recentPaths = new Set(filteredRecentProjects.map(rp => rp.path));
+        const nonRecentProjects = filteredProjects.filter(project => !recentPaths.has(project.path));
+        // Add "All Projects" separator if we have both recent and other projects
+        if (filteredRecentProjects.length > 0 &&
+            nonRecentProjects.length > 0 &&
+            !isSearchMode) {
+            menuItems.push({
+                label: '── All Projects ──',
+                value: 'separator-all',
+            });
+        }
+        // Build menu items from filtered non-recent projects
+        nonRecentProjects.forEach(project => {
+            // Get session counts for this project
+            const projectSessions = globalSessionOrchestrator.getProjectSessions(project.path);
+            const counts = SessionManager.getSessionCounts(projectSessions);
+            const countsFormatted = SessionManager.formatSessionCounts(counts);
+            // Only show numbers for total items (0-9) when not in search mode
+            const numberPrefix = !isSearchMode && currentIndex < 10 ? `${currentIndex} ❯ ` : '❯ ';
+            menuItems.push({
+                label: numberPrefix + project.name + countsFormatted,
+                value: project.path,
+                project,
+            });
+            currentIndex++;
+        });
+        // Add menu options only when not in search mode
+        if (!isSearchMode) {
+            if (projects.length > 0) {
+                menuItems.push({
+                    label: '─────────────',
+                    value: 'separator',
+                });
+            }
+            menuItems.push({
+                label: `R 🔄 Refresh`,
+                value: 'refresh',
+            });
+            menuItems.push({
+                label: `Q ${MENU_ICONS.EXIT} Exit`,
+                value: 'exit',
+            });
+        }
+        setItems(menuItems);
+    }, [projects, recentProjects, searchQuery, isSearchMode]);
+    // Handle hotkeys
+    useInput((input, _key) => {
+        // Skip in test environment to avoid stdin.ref error
+        if (!process.stdin.setRawMode) {
+            return;
+        }
+        // Dismiss error on any key press when error is shown
+        if (displayError && onDismissError) {
+            onDismissError();
+            return;
+        }
+        // Don't process other keys if in search mode (handled by useSearchMode)
+        if (isSearchMode) {
+            return;
+        }
+        const keyPressed = input.toLowerCase();
+        // Handle number keys 0-9 for project selection
+        if (/^[0-9]$/.test(keyPressed)) {
+            const index = parseInt(keyPressed);
+            // Get all selectable items (recent + non-recent projects)
+            const selectableItems = items.filter(item => item.project);
+            if (index < Math.min(10, selectableItems.length) &&
+                selectableItems[index]?.project) {
+                onSelectProject(selectableItems[index].project);
+            }
+            return;
+        }
+        switch (keyPressed) {
+            case 'r':
+                // Refresh project list
+                loadProjects();
+                break;
+            case 'q':
+            case 'x':
+                // Trigger exit action
+                onSelectProject({
+                    path: 'EXIT_APPLICATION',
+                    name: '',
+                    relativePath: '',
+                    isValid: false,
+                });
+                break;
+        }
+    });
+    const handleSelect = (item) => {
+        if (item.value.startsWith('separator')) {
+            // Do nothing for separators
+        }
+        else if (item.value === 'refresh') {
+            loadProjects();
+        }
+        else if (item.value === 'exit') {
+            // Handle exit
+            onSelectProject({
+                path: 'EXIT_APPLICATION',
+                name: '',
+                relativePath: '',
+                isValid: false,
+            });
+        }
+        else if (item.project) {
+            onSelectProject(item.project);
+        }
+    };
+    return (React.createElement(Box, { flexDirection: "column" },
+        React.createElement(Box, { marginBottom: 1 },
+            React.createElement(Text, { bold: true, color: "green" }, "CCManager - Multi-Project Mode")),
+        React.createElement(Box, { marginBottom: 1 },
+            React.createElement(Text, { dimColor: true }, "Select a project:")),
+        isSearchMode && (React.createElement(Box, { marginBottom: 1 },
+            React.createElement(Text, null, "Search: "),
+            React.createElement(TextInputWrapper, { value: searchQuery, onChange: setSearchQuery, focus: true, placeholder: "Type to filter projects..." }))),
+        loading ? (React.createElement(Box, null,
+            React.createElement(Text, { color: "yellow" }, "Loading projects..."))) : projects.length === 0 && !displayError ? (React.createElement(Box, null,
+            React.createElement(Text, { color: "yellow" },
+                "No git repositories found in ",
+                projectsDir))) : isSearchMode && items.length === 0 ? (React.createElement(Box, null,
+            React.createElement(Text, { color: "yellow" }, "No projects match your search"))) : isSearchMode ? (
+        // In search mode, show the items as a list without SelectInput
+        React.createElement(Box, { flexDirection: "column" }, items.slice(0, limit).map((item, index) => (React.createElement(Text, { key: item.value, color: index === selectedIndex ? 'green' : undefined },
+            index === selectedIndex ? '❯ ' : '  ',
+            item.label))))) : (React.createElement(SelectInput, { items: items, onSelect: handleSelect, isFocused: !displayError, limit: limit, initialIndex: selectedIndex })),
+        displayError && (React.createElement(Box, { marginTop: 1, paddingX: 1, borderStyle: "round", borderColor: "red" },
+            React.createElement(Box, { flexDirection: "column" },
+                React.createElement(Text, { color: "red", bold: true },
+                    "Error: ",
+                    displayError),
+                React.createElement(Text, { color: "gray", dimColor: true }, "Press any key to dismiss")))),
+        React.createElement(Box, { marginTop: 1, flexDirection: "column" },
+            (isSearchMode || searchQuery) && (React.createElement(Text, { dimColor: true },
+                "Projects: ",
+                items.filter(item => item.project).length,
+                " of",
+                ' ',
+                projects.length,
+                " shown")),
+            React.createElement(Text, { dimColor: true }, isSearchMode
+                ? 'Search Mode: Type to filter, Enter to exit search, ESC to exit search'
+                : searchQuery
+                    ? `Filtered: "${searchQuery}" | ↑↓ Navigate Enter Select | /-Search ESC-Clear 0-9 Quick Select R-Refresh Q-Quit`
+                    : 'Controls: ↑↓ Navigate Enter Select | Hotkeys: 0-9 Quick Select /-Search R-Refresh Q-Quit'))));
+};
+export default ProjectList;

package/dist/components/ProjectList.recent-projects.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/components/ProjectList.recent-projects.test.js

@@ -0,0 +1,186 @@
+import React from 'react';
+import { render } from 'ink-testing-library';
+import { expect, describe, it, vi, beforeEach, afterEach } from 'vitest';
+import ProjectList from './ProjectList.js';
+import { projectManager } from '../services/projectManager.js';
+// Mock ink to avoid stdin.ref issues
+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 => (React.createElement(Text, { key: item.value }, item.label)))));
+        },
+    };
+});
+vi.mock('../services/projectManager.js', () => ({
+    projectManager: {
+        instance: {
+            discoverProjects: vi.fn(),
+        },
+        getRecentProjects: vi.fn(),
+    },
+}));
+describe('ProjectList - Recent Projects', () => {
+    const mockOnSelectProject = vi.fn();
+    const mockOnDismissError = vi.fn();
+    let originalSetRawMode;
+    const createProject = (name, path) => ({
+        name,
+        path,
+        relativePath: `./${name}`,
+        isValid: true,
+    });
+    const mockProjects = [
+        createProject('project-a', '/home/user/projects/project-a'),
+        createProject('project-b', '/home/user/projects/project-b'),
+        createProject('project-c', '/home/user/projects/project-c'),
+        createProject('project-d', '/home/user/projects/project-d'),
+        createProject('project-e', '/home/user/projects/project-e'),
+    ];
+    beforeEach(() => {
+        vi.clearAllMocks();
+        vi.mocked(projectManager.instance.discoverProjects).mockResolvedValue(mockProjects);
+        vi.mocked(projectManager.getRecentProjects).mockReturnValue([]);
+        // Mock stdin.setRawMode
+        originalSetRawMode = process.stdin.setRawMode;
+        process.stdin.setRawMode = vi.fn();
+    });
+    afterEach(() => {
+        // Restore original setRawMode
+        process.stdin.setRawMode = originalSetRawMode;
+    });
+    it('should display recent projects at the top when available', async () => {
+        // Mock recent projects
+        vi.mocked(projectManager.getRecentProjects).mockReturnValue([
+            {
+                name: 'project-c',
+                path: '/home/user/projects/project-c',
+                lastAccessed: Date.now() - 1000,
+            },
+            {
+                name: 'project-e',
+                path: '/home/user/projects/project-e',
+                lastAccessed: Date.now() - 2000,
+            },
+        ]);
+        const { lastFrame } = render(React.createElement(ProjectList, { projectsDir: "/home/user/projects", onSelectProject: mockOnSelectProject, error: null, onDismissError: mockOnDismissError }));
+        // Wait for projects to load
+        await vi.waitFor(() => {
+            expect(lastFrame()).toContain('project-c');
+        });
+        // Check that recent projects section is shown
+        expect(lastFrame()).toContain('Recent');
+        // Check that recent projects are at the top
+        const output = lastFrame();
+        const projectCIndex = output?.indexOf('project-c') ?? -1;
+        const projectEIndex = output?.indexOf('project-e') ?? -1;
+        const allProjectsIndex = output?.indexOf('All Projects') ?? -1;
+        // Recent projects should appear before "All Projects" section
+        expect(projectCIndex).toBeLessThan(allProjectsIndex);
+        expect(projectEIndex).toBeLessThan(allProjectsIndex);
+    });
+    it('should not show recent projects section when there are none', async () => {
+        vi.mocked(projectManager.getRecentProjects).mockReturnValue([]);
+        const { lastFrame } = render(React.createElement(ProjectList, { projectsDir: "/home/user/projects", onSelectProject: mockOnSelectProject, error: null, onDismissError: mockOnDismissError }));
+        // Wait for projects to load
+        await vi.waitFor(() => {
+            expect(lastFrame()).toContain('project-a');
+        });
+        // Check that recent projects section is not shown
+        expect(lastFrame()).not.toContain('Recent');
+    });
+    it('should handle selection of recent projects', async () => {
+        // Skip this test for now - SelectInput interaction is complex to test
+        // The selection functionality is covered by the number key test
+    });
+    it('should filter recent projects based on search query', async () => {
+        // This functionality is tested in the main ProjectList.test.tsx
+        // Skip in recent projects specific tests to avoid complexity
+    });
+    it('should show recent projects with correct number prefixes', async () => {
+        // Mock recent projects that match existing projects
+        vi.mocked(projectManager.getRecentProjects).mockReturnValue([
+            {
+                name: 'project-c',
+                path: '/home/user/projects/project-c',
+                lastAccessed: Date.now() - 1000,
+            },
+            {
+                name: 'project-e',
+                path: '/home/user/projects/project-e',
+                lastAccessed: Date.now() - 2000,
+            },
+        ]);
+        const { lastFrame } = render(React.createElement(ProjectList, { projectsDir: "/home/user/projects", onSelectProject: mockOnSelectProject, error: null, onDismissError: mockOnDismissError }));
+        // Wait for projects to load
+        await vi.waitFor(() => {
+            expect(lastFrame()).toContain('project-c');
+        });
+        // Check that recent projects have correct number prefixes
+        const output = lastFrame();
+        expect(output).toContain('0 ❯ project-c');
+        expect(output).toContain('1 ❯ project-e');
+        // Check that regular projects start from the next available number
+        expect(output).toContain('2 ❯ project-a');
+    });
+    it('should show all recent projects without limit', async () => {
+        // Create 10 projects
+        const manyProjects = Array.from({ length: 10 }, (_, i) => createProject(`project-${i}`, `/home/user/projects/project-${i}`));
+        // Mock discovered projects
+        vi.mocked(projectManager.instance.discoverProjects).mockResolvedValue(manyProjects);
+        // Mock more than 5 recent projects
+        const manyRecentProjects = Array.from({ length: 10 }, (_, i) => ({
+            name: `project-${i}`,
+            path: `/home/user/projects/project-${i}`,
+            lastAccessed: Date.now() - i * 1000,
+        }));
+        vi.mocked(projectManager.getRecentProjects).mockReturnValue(manyRecentProjects);
+        const { lastFrame } = render(React.createElement(ProjectList, { projectsDir: "/home/user/projects", onSelectProject: mockOnSelectProject, error: null, onDismissError: mockOnDismissError }));
+        // Wait for projects to load
+        await vi.waitFor(() => {
+            expect(lastFrame()).toContain('project-0');
+        });
+        // Check that all 10 recent projects are shown (not limited to 5)
+        const output = lastFrame();
+        for (let i = 0; i < 10; i++) {
+            expect(output).toContain(`project-${i}`);
+        }
+    });
+    it('should allow number key selection for recent projects', async () => {
+        // Mock recent projects
+        vi.mocked(projectManager.getRecentProjects).mockReturnValue([
+            {
+                name: 'project-c',
+                path: '/home/user/projects/project-c',
+                lastAccessed: Date.now(),
+            },
+        ]);
+        // Mock the useInput hook to capture the handler
+        const mockUseInput = vi.mocked(await import('ink')).useInput;
+        let inputHandler = () => { };
+        mockUseInput.mockImplementation(handler => {
+            inputHandler = handler;
+        });
+        const { lastFrame } = render(React.createElement(ProjectList, { projectsDir: "/home/user/projects", onSelectProject: mockOnSelectProject, error: null, onDismissError: mockOnDismissError }));
+        // Wait for projects to load
+        await vi.waitFor(() => {
+            expect(lastFrame()).toContain('project-c');
+        });
+        // Simulate pressing 0 to select first recent project
+        inputHandler('0');
+        // Check that the recent project was selected
+        expect(mockOnSelectProject).toHaveBeenCalledWith(expect.objectContaining({
+            name: 'project-c',
+            path: '/home/user/projects/project-c',
+        }));
+    });
+});

package/dist/components/ProjectList.test.d.ts

@@ -0,0 +1 @@
+export {};