ccmanager 1.4.5 → 2.1.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/NewWorktree.js

@@ -6,9 +6,11 @@ import { shortcutManager } from '../services/shortcutManager.js';
 import { configurationManager } from '../services/configurationManager.js';
 import { generateWorktreeDirectory } from '../utils/worktreeUtils.js';
 import { WorktreeService } from '../services/worktreeService.js';
+import { useSearchMode } from '../hooks/useSearchMode.js';
 const NewWorktree = ({ onComplete, onCancel }) => {
     const worktreeConfig = configurationManager.getWorktreeConfig();
     const isAutoDirectory = worktreeConfig.autoDirectory;
+    const limit = 10;
     // Adjust initial step based on auto directory mode
     const [step, setStep] = useState(isAutoDirectory ? 'branch' : 'path');
     const [path, setPath] = useState('');
@@ -27,16 +29,32 @@ const NewWorktree = ({ onComplete, onCancel }) => {
         };
     }, []); // Empty deps array - only initialize once
     // Create branch items with default branch first (memoized)
-    const branchItems = useMemo(() => [
+    const allBranchItems = useMemo(() => [
         { label: `${defaultBranch} (default)`, value: defaultBranch },
         ...branches
             .filter(br => br !== defaultBranch)
             .map(br => ({ label: br, value: br })),
     ], [branches, defaultBranch]);
+    // Use search mode for base branch selection
+    const { isSearchMode, searchQuery, selectedIndex, setSearchQuery } = useSearchMode(allBranchItems.length, {
+        isDisabled: step !== 'base-branch',
+    });
+    // Filter branch items based on search query
+    const branchItems = useMemo(() => {
+        if (!searchQuery)
+            return allBranchItems;
+        return allBranchItems.filter(item => item.value.toLowerCase().includes(searchQuery.toLowerCase()));
+    }, [allBranchItems, searchQuery]);
     useInput((input, key) => {
         if (shortcutManager.matchesShortcut('cancel', input, key)) {
             onCancel();
         }
+        // Handle arrow key navigation in search mode for base branch selection
+        if (step === 'base-branch' && isSearchMode) {
+            // Don't handle any keys here - let useSearchMode handle them
+            // The hook will handle arrow keys for navigation and Enter to exit search mode
+            return;
+        }
     });
     const handlePathSubmit = (value) => {
         if (value.trim()) {
@@ -109,7 +127,17 @@ const NewWorktree = ({ onComplete, onCancel }) => {
                     "Select base branch for ",
                     React.createElement(Text, { color: "cyan" }, branch),
                     ":")),
-            React.createElement(SelectInput, { items: branchItems, onSelect: handleBaseBranchSelect, initialIndex: 0, limit: 10 }))),
+            isSearchMode && (React.createElement(Box, { marginBottom: 1 },
+                React.createElement(Text, null, "Search: "),
+                React.createElement(TextInputWrapper, { value: searchQuery, onChange: setSearchQuery, focus: true, placeholder: "Type to filter branches..." }))),
+            isSearchMode && branchItems.length === 0 ? (React.createElement(Box, null,
+                React.createElement(Text, { color: "yellow" }, "No branches match your search"))) : isSearchMode ? (
+            // In search mode, show the items as a list without SelectInput
+            React.createElement(Box, { flexDirection: "column" }, branchItems.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: branchItems, onSelect: handleBaseBranchSelect, initialIndex: selectedIndex, limit: limit, isFocused: !isSearchMode })),
+            !isSearchMode && (React.createElement(Box, { marginTop: 1 },
+                React.createElement(Text, { dimColor: true }, "Press / to search"))))),
         step === 'copy-settings' && (React.createElement(Box, { flexDirection: "column" },
             React.createElement(Box, { marginBottom: 1 },
                 React.createElement(Text, null,

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 {};