ccmanager 1.4.5 → 2.1.0

package/dist/components/ProjectList.test.js

@@ -0,0 +1,501 @@
+import React from 'react';
+import { render } from 'ink-testing-library';
+import { describe, it, expect, vi, beforeEach } from 'vitest';
+// 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 the projectManager
+vi.mock('../services/projectManager.js', () => ({
+    projectManager: {
+        instance: {
+            discoverProjects: vi.fn(),
+        },
+        getRecentProjects: vi.fn().mockReturnValue([]),
+    },
+}));
+// Now import after mocking
+const { default: ProjectList } = await import('./ProjectList.js');
+const { projectManager } = await import('../services/projectManager.js');
+describe('ProjectList', () => {
+    const mockOnSelectProject = vi.fn();
+    const mockOnDismissError = vi.fn();
+    const mockProjects = [
+        {
+            name: 'project1',
+            path: '/projects/project1',
+            relativePath: 'project1',
+            isValid: true,
+        },
+        {
+            name: 'project2',
+            path: '/projects/project2',
+            relativePath: 'project2',
+            isValid: true,
+        },
+        {
+            name: 'project3',
+            path: '/projects/project3',
+            relativePath: 'project3',
+            isValid: true,
+        },
+    ];
+    beforeEach(() => {
+        vi.clearAllMocks();
+        vi.mocked(projectManager.instance.discoverProjects).mockResolvedValue(mockProjects);
+    });
+    it('should render project list with correct title', () => {
+        const { lastFrame } = render(React.createElement(ProjectList, { projectsDir: "/projects", onSelectProject: mockOnSelectProject, error: null, onDismissError: mockOnDismissError }));
+        expect(lastFrame()).toContain('CCManager - Multi-Project Mode');
+        expect(lastFrame()).toContain('Select a project:');
+    });
+    it('should display loading state initially', () => {
+        // Create a promise that never resolves to keep loading state
+        vi.mocked(projectManager.instance.discoverProjects).mockReturnValue(new Promise(() => { }));
+        const { lastFrame } = render(React.createElement(ProjectList, { projectsDir: "/projects", onSelectProject: mockOnSelectProject, error: null, onDismissError: mockOnDismissError }));
+        expect(lastFrame()).toContain('Loading projects...');
+    });
+    it('should display projects after loading', async () => {
+        const { lastFrame, rerender } = render(React.createElement(ProjectList, { projectsDir: "/projects", onSelectProject: mockOnSelectProject, error: null, onDismissError: mockOnDismissError }));
+        // Wait a bit for async operations
+        await new Promise(resolve => setTimeout(resolve, 100));
+        // Force rerender
+        rerender(React.createElement(ProjectList, { projectsDir: "/projects", onSelectProject: mockOnSelectProject, error: null, onDismissError: mockOnDismissError }));
+        // Wait for SelectInput to render with our mock
+        await vi.waitFor(() => {
+            const frame = lastFrame();
+            return frame && !frame.includes('Loading projects...');
+        }, { timeout: 2000 });
+        const frame = lastFrame();
+        expect(frame).toContain('0 ❯ project1');
+        expect(frame).toContain('1 ❯ project2');
+        expect(frame).toContain('2 ❯ project3');
+    });
+    it('should display error when provided', () => {
+        const { lastFrame } = render(React.createElement(ProjectList, { projectsDir: "/projects", onSelectProject: mockOnSelectProject, error: "Failed to load projects", onDismissError: mockOnDismissError }));
+        expect(lastFrame()).toContain('Error: Failed to load projects');
+        expect(lastFrame()).toContain('Press any key to dismiss');
+    });
+    it('should handle project selection via menu', async () => {
+        const { lastFrame, rerender } = render(React.createElement(ProjectList, { projectsDir: "/projects", onSelectProject: mockOnSelectProject, error: null, onDismissError: mockOnDismissError }));
+        // Wait a bit for async operations
+        await new Promise(resolve => setTimeout(resolve, 100));
+        // Force rerender
+        rerender(React.createElement(ProjectList, { projectsDir: "/projects", onSelectProject: mockOnSelectProject, error: null, onDismissError: mockOnDismissError }));
+        // Wait for component to update after async loading
+        await vi.waitFor(() => {
+            const frame = lastFrame();
+            return frame && !frame.includes('Loading projects...');
+        });
+        // Verify menu structure
+        const frame = lastFrame();
+        expect(frame).toContain('0 ❯ project1');
+        expect(frame).toContain('R');
+        expect(frame).toContain('Refresh');
+        expect(frame).toContain('Q');
+        expect(frame).toContain('Exit');
+    });
+    it('should display number shortcuts for first 10 projects', async () => {
+        const { lastFrame, rerender } = render(React.createElement(ProjectList, { projectsDir: "/projects", onSelectProject: mockOnSelectProject, error: null, onDismissError: mockOnDismissError }));
+        // Wait a bit for async operations
+        await new Promise(resolve => setTimeout(resolve, 100));
+        // Force rerender
+        rerender(React.createElement(ProjectList, { projectsDir: "/projects", onSelectProject: mockOnSelectProject, error: null, onDismissError: mockOnDismissError }));
+        // Wait for projects to load
+        await vi.waitFor(() => {
+            const frame = lastFrame();
+            return frame && !frame.includes('Loading projects...');
+        });
+        // Verify number prefixes are shown
+        const frame = lastFrame();
+        expect(frame).toContain('0 ❯ project1');
+        expect(frame).toContain('1 ❯ project2');
+        expect(frame).toContain('2 ❯ project3');
+    });
+    it('should display exit option in menu', async () => {
+        const { lastFrame, rerender } = render(React.createElement(ProjectList, { projectsDir: "/projects", onSelectProject: mockOnSelectProject, error: null, onDismissError: mockOnDismissError }));
+        // Wait a bit for async operations
+        await new Promise(resolve => setTimeout(resolve, 100));
+        // Force rerender
+        rerender(React.createElement(ProjectList, { projectsDir: "/projects", onSelectProject: mockOnSelectProject, error: null, onDismissError: mockOnDismissError }));
+        // Wait for projects to load
+        await vi.waitFor(() => {
+            const frame = lastFrame();
+            return frame && !frame.includes('Loading projects...');
+        });
+        // Verify exit option is shown
+        const frame = lastFrame();
+        expect(frame).toContain('Q');
+        expect(frame).toContain('Exit');
+    });
+    it('should display refresh option in menu', async () => {
+        const { lastFrame } = render(React.createElement(ProjectList, { projectsDir: "/projects", onSelectProject: mockOnSelectProject, error: null, onDismissError: mockOnDismissError }));
+        // Wait for projects to load
+        await vi.waitFor(() => {
+            return lastFrame()?.includes('project1') ?? false;
+        });
+        // Verify refresh option is shown
+        const frame = lastFrame();
+        expect(frame).toContain('R');
+        expect(frame).toContain('Refresh');
+    });
+    it('should show empty state when no projects found', async () => {
+        vi.mocked(projectManager.instance.discoverProjects).mockResolvedValue([]);
+        const { lastFrame, rerender } = render(React.createElement(ProjectList, { projectsDir: "/projects", onSelectProject: mockOnSelectProject, error: null, onDismissError: mockOnDismissError }));
+        // Wait for projects to load
+        await vi.waitFor(() => {
+            rerender(React.createElement(ProjectList, { projectsDir: "/projects", onSelectProject: mockOnSelectProject, error: null, onDismissError: mockOnDismissError }));
+            return lastFrame()?.includes('No git repositories found') ?? false;
+        });
+        expect(lastFrame()).toContain('No git repositories found in /projects');
+    });
+    it('should display error message when error prop is provided', () => {
+        const { lastFrame } = render(React.createElement(ProjectList, { projectsDir: "/projects", onSelectProject: mockOnSelectProject, error: "Test error", onDismissError: mockOnDismissError }));
+        expect(lastFrame()).toContain('Error: Test error');
+        expect(lastFrame()).toContain('Press any key to dismiss');
+    });
+    describe('search functionality', () => {
+        it.skip('should enter search mode when "/" key is pressed', async () => {
+            const mockUseInput = vi.mocked(await import('ink')).useInput;
+            const inputHandlers = [];
+            mockUseInput.mockImplementation(handler => {
+                inputHandlers.push(handler);
+            });
+            // Need to set up stdin.setRawMode for the test
+            const originalSetRawMode = process.stdin.setRawMode;
+            process.stdin.setRawMode = vi.fn();
+            const { lastFrame, rerender } = render(React.createElement(ProjectList, { projectsDir: "/projects", onSelectProject: mockOnSelectProject, error: null, onDismissError: mockOnDismissError }));
+            // Wait for projects to load
+            await vi.waitFor(() => {
+                return lastFrame()?.includes('project1') ?? false;
+            });
+            // Simulate pressing "/" key on all handlers (both from useSearchMode and ProjectList)
+            inputHandlers.forEach(handler => {
+                handler('/', {
+                    escape: false,
+                    return: false,
+                    leftArrow: false,
+                    rightArrow: false,
+                    upArrow: false,
+                    downArrow: false,
+                    pageDown: false,
+                    pageUp: false,
+                    ctrl: false,
+                    shift: false,
+                    tab: false,
+                    backspace: false,
+                    delete: false,
+                    meta: false,
+                });
+            });
+            // Wait a bit for state update
+            await new Promise(resolve => setTimeout(resolve, 50));
+            // Force rerender to see updated state
+            rerender(React.createElement(ProjectList, { projectsDir: "/projects", onSelectProject: mockOnSelectProject, error: null, onDismissError: mockOnDismissError }));
+            // Should show search input
+            expect(lastFrame()).toContain('Search:');
+            // Restore original
+            process.stdin.setRawMode = originalSetRawMode;
+        });
+        it('should filter projects based on search query', async () => {
+            const mockUseInput = vi.mocked(await import('ink')).useInput;
+            let inputHandler = () => { };
+            mockUseInput.mockImplementation(handler => {
+                inputHandler = handler;
+            });
+            const { lastFrame, rerender } = render(React.createElement(ProjectList, { projectsDir: "/projects", onSelectProject: mockOnSelectProject, error: null, onDismissError: mockOnDismissError }));
+            // Wait for projects to load
+            await vi.waitFor(() => {
+                return lastFrame()?.includes('project1') ?? false;
+            });
+            // Enter search mode
+            inputHandler('/', {
+                escape: false,
+                return: false,
+                leftArrow: false,
+                rightArrow: false,
+                upArrow: false,
+                downArrow: false,
+                pageDown: false,
+                pageUp: false,
+                ctrl: false,
+                shift: false,
+                tab: false,
+                backspace: false,
+                delete: false,
+                meta: false,
+            });
+            // Force rerender with search active and query
+            rerender(React.createElement(ProjectList, { projectsDir: "/projects", onSelectProject: mockOnSelectProject, error: null, onDismissError: mockOnDismissError }));
+            // Simulate typing "project2" in search
+            // This would be handled by the TextInput component
+            // We'll test the filtering logic separately
+        });
+        it.skip('should exit search mode but keep filter when ESC is pressed in search mode', async () => {
+            const mockUseInput = vi.mocked(await import('ink')).useInput;
+            let inputHandler = () => { };
+            mockUseInput.mockImplementation(handler => {
+                inputHandler = handler;
+            });
+            // Need to set up stdin.setRawMode for the test
+            const originalSetRawMode = process.stdin.setRawMode;
+            process.stdin.setRawMode = vi.fn();
+            const { lastFrame, rerender } = render(React.createElement(ProjectList, { projectsDir: "/projects", onSelectProject: mockOnSelectProject, error: null, onDismissError: mockOnDismissError }));
+            // Wait for projects to load
+            await vi.waitFor(() => {
+                return lastFrame()?.includes('project1') ?? false;
+            });
+            // Enter search mode
+            inputHandler('/', {
+                escape: false,
+                return: false,
+                leftArrow: false,
+                rightArrow: false,
+                upArrow: false,
+                downArrow: false,
+                pageDown: false,
+                pageUp: false,
+                ctrl: false,
+                shift: false,
+                tab: false,
+                backspace: false,
+                delete: false,
+                meta: false,
+            });
+            // Wait a bit for state update
+            await new Promise(resolve => setTimeout(resolve, 50));
+            // Force rerender
+            rerender(React.createElement(ProjectList, { projectsDir: "/projects", onSelectProject: mockOnSelectProject, error: null, onDismissError: mockOnDismissError }));
+            // Should be in search mode
+            expect(lastFrame()).toContain('Search:');
+            // Press ESC
+            inputHandler('', {
+                escape: true,
+                return: false,
+                leftArrow: false,
+                rightArrow: false,
+                upArrow: false,
+                downArrow: false,
+                pageDown: false,
+                pageUp: false,
+                ctrl: false,
+                shift: false,
+                tab: false,
+                backspace: false,
+                delete: false,
+                meta: false,
+            });
+            // Wait a bit for state update
+            await new Promise(resolve => setTimeout(resolve, 50));
+            // Force rerender
+            rerender(React.createElement(ProjectList, { projectsDir: "/projects", onSelectProject: mockOnSelectProject, error: null, onDismissError: mockOnDismissError }));
+            // Should exit search mode
+            expect(lastFrame()).not.toContain('Search:');
+            // Restore original
+            process.stdin.setRawMode = originalSetRawMode;
+        });
+        it('should not enter search mode when "/" is pressed during error display', async () => {
+            const mockUseInput = vi.mocked(await import('ink')).useInput;
+            let inputHandler = () => { };
+            mockUseInput.mockImplementation(handler => {
+                inputHandler = handler;
+            });
+            // Need to set up stdin.setRawMode for the test
+            const originalSetRawMode = process.stdin.setRawMode;
+            process.stdin.setRawMode = vi.fn();
+            const { lastFrame, rerender } = render(React.createElement(ProjectList, { projectsDir: "/projects", onSelectProject: mockOnSelectProject, error: "Test error", onDismissError: mockOnDismissError }));
+            // Press "/" key
+            inputHandler('/', {
+                escape: false,
+                return: false,
+                leftArrow: false,
+                rightArrow: false,
+                upArrow: false,
+                downArrow: false,
+                pageDown: false,
+                pageUp: false,
+                ctrl: false,
+                shift: false,
+                tab: false,
+                backspace: false,
+                delete: false,
+                meta: false,
+            });
+            // Wait a bit for state update
+            await new Promise(resolve => setTimeout(resolve, 50));
+            // Force rerender
+            rerender(React.createElement(ProjectList, { projectsDir: "/projects", onSelectProject: mockOnSelectProject, error: "Test error", onDismissError: mockOnDismissError }));
+            // Should not show search input, should dismiss error instead
+            expect(lastFrame()).not.toContain('Search:');
+            expect(mockOnDismissError).toHaveBeenCalled();
+            // Restore original
+            process.stdin.setRawMode = originalSetRawMode;
+        });
+        it.skip('should exit search mode when Enter is pressed but keep filter', async () => {
+            const mockUseInput = vi.mocked(await import('ink')).useInput;
+            let inputHandler = () => { };
+            mockUseInput.mockImplementation(handler => {
+                inputHandler = handler;
+            });
+            // Need to set up stdin.setRawMode for the test
+            const originalSetRawMode = process.stdin.setRawMode;
+            process.stdin.setRawMode = vi.fn();
+            const { lastFrame, rerender } = render(React.createElement(ProjectList, { projectsDir: "/projects", onSelectProject: mockOnSelectProject, error: null, onDismissError: mockOnDismissError }));
+            // Wait for projects to load
+            await vi.waitFor(() => {
+                return lastFrame()?.includes('project1') ?? false;
+            });
+            // Enter search mode
+            inputHandler('/', {
+                escape: false,
+                return: false,
+                leftArrow: false,
+                rightArrow: false,
+                upArrow: false,
+                downArrow: false,
+                pageDown: false,
+                pageUp: false,
+                ctrl: false,
+                shift: false,
+                tab: false,
+                backspace: false,
+                delete: false,
+                meta: false,
+            });
+            // Wait a bit for state update
+            await new Promise(resolve => setTimeout(resolve, 50));
+            // Force rerender
+            rerender(React.createElement(ProjectList, { projectsDir: "/projects", onSelectProject: mockOnSelectProject, error: null, onDismissError: mockOnDismissError }));
+            // Should be in search mode
+            expect(lastFrame()).toContain('Search:');
+            // Press Enter
+            inputHandler('', {
+                escape: false,
+                return: true,
+                leftArrow: false,
+                rightArrow: false,
+                upArrow: false,
+                downArrow: false,
+                pageDown: false,
+                pageUp: false,
+                ctrl: false,
+                shift: false,
+                tab: false,
+                backspace: false,
+                delete: false,
+                meta: false,
+            });
+            // Wait a bit for state update
+            await new Promise(resolve => setTimeout(resolve, 50));
+            // Force rerender
+            rerender(React.createElement(ProjectList, { projectsDir: "/projects", onSelectProject: mockOnSelectProject, error: null, onDismissError: mockOnDismissError }));
+            // Should exit search mode
+            expect(lastFrame()).not.toContain('Search:');
+            // Should not have called onSelectProject
+            expect(mockOnSelectProject).not.toHaveBeenCalled();
+            // Restore original
+            process.stdin.setRawMode = originalSetRawMode;
+        });
+        it('should clear filter when ESC is pressed outside search mode', async () => {
+            const mockUseInput = vi.mocked(await import('ink')).useInput;
+            let inputHandler = () => { };
+            mockUseInput.mockImplementation(handler => {
+                inputHandler = handler;
+            });
+            // Need to set up stdin.setRawMode for the test
+            const originalSetRawMode = process.stdin.setRawMode;
+            process.stdin.setRawMode = vi.fn();
+            const { lastFrame, rerender } = render(React.createElement(ProjectList, { projectsDir: "/projects", onSelectProject: mockOnSelectProject, error: null, onDismissError: mockOnDismissError }));
+            // Wait for projects to load
+            await vi.waitFor(() => {
+                return lastFrame()?.includes('project1') ?? false;
+            });
+            // Enter search mode
+            inputHandler('/', {
+                escape: false,
+                return: false,
+                leftArrow: false,
+                rightArrow: false,
+                upArrow: false,
+                downArrow: false,
+                pageDown: false,
+                pageUp: false,
+                ctrl: false,
+                shift: false,
+                tab: false,
+                backspace: false,
+                delete: false,
+                meta: false,
+            });
+            await new Promise(resolve => setTimeout(resolve, 50));
+            // Exit search mode with Enter (keeping filter)
+            inputHandler('', {
+                escape: false,
+                return: true,
+                leftArrow: false,
+                rightArrow: false,
+                upArrow: false,
+                downArrow: false,
+                pageDown: false,
+                pageUp: false,
+                ctrl: false,
+                shift: false,
+                tab: false,
+                backspace: false,
+                delete: false,
+                meta: false,
+            });
+            await new Promise(resolve => setTimeout(resolve, 50));
+            // Now press ESC outside search mode to clear filter
+            inputHandler('', {
+                escape: true,
+                return: false,
+                leftArrow: false,
+                rightArrow: false,
+                upArrow: false,
+                downArrow: false,
+                pageDown: false,
+                pageUp: false,
+                ctrl: false,
+                shift: false,
+                tab: false,
+                backspace: false,
+                delete: false,
+                meta: false,
+            });
+            await new Promise(resolve => setTimeout(resolve, 50));
+            // Force rerender
+            rerender(React.createElement(ProjectList, { projectsDir: "/projects", onSelectProject: mockOnSelectProject, error: null, onDismissError: mockOnDismissError }));
+            // Should display all projects (filter cleared)
+            expect(lastFrame()).toContain('project1');
+            expect(lastFrame()).toContain('project2');
+            expect(lastFrame()).toContain('project3');
+            // Restore original
+            process.stdin.setRawMode = originalSetRawMode;
+        });
+    });
+});

package/dist/constants/env.d.ts

@@ -0,0 +1,3 @@
+export declare const ENV_VARS: {
+    readonly MULTI_PROJECT_ROOT: "CCMANAGER_MULTI_PROJECT_ROOT";
+};

package/dist/constants/env.js

@@ -0,0 +1,4 @@
+// Environment variable names
+export const ENV_VARS = {
+    MULTI_PROJECT_ROOT: 'CCMANAGER_MULTI_PROJECT_ROOT',
+};

package/dist/constants/error.d.ts

@@ -0,0 +1,6 @@
+export declare const MULTI_PROJECT_ERRORS: {
+    readonly NO_PROJECTS_DIR: "CCMANAGER_MULTI_PROJECT_ROOT environment variable is required in multi-project mode";
+    readonly INVALID_PROJECTS_DIR: "CCMANAGER_MULTI_PROJECT_ROOT points to a non-existent directory";
+    readonly NO_PROJECTS_FOUND: "No git repositories found in the projects directory";
+    readonly CORRUPTED_REPO: "Git repository is corrupted or inaccessible";
+};

package/dist/constants/error.js

@@ -0,0 +1,7 @@
+// Error messages for multi-project mode
+export const MULTI_PROJECT_ERRORS = {
+    NO_PROJECTS_DIR: 'CCMANAGER_MULTI_PROJECT_ROOT environment variable is required in multi-project mode',
+    INVALID_PROJECTS_DIR: 'CCMANAGER_MULTI_PROJECT_ROOT points to a non-existent directory',
+    NO_PROJECTS_FOUND: 'No git repositories found in the projects directory',
+    CORRUPTED_REPO: 'Git repository is corrupted or inaccessible',
+};

package/dist/hooks/useSearchMode.d.ts

@@ -0,0 +1,15 @@
+interface UseSearchModeOptions {
+    onEscape?: () => void;
+    onEnter?: () => void;
+    skipInTest?: boolean;
+    isDisabled?: boolean;
+}
+interface UseSearchModeReturn {
+    isSearchMode: boolean;
+    searchQuery: string;
+    selectedIndex: number;
+    setSearchQuery: (query: string) => void;
+    setSelectedIndex: (index: number) => void;
+}
+export declare function useSearchMode(itemsLength: number, options?: UseSearchModeOptions): UseSearchModeReturn;
+export {};

package/dist/hooks/useSearchMode.js

@@ -0,0 +1,67 @@
+import { useState, useEffect } from 'react';
+import { useInput } from 'ink';
+export function useSearchMode(itemsLength, options = {}) {
+    const [isSearchMode, setIsSearchMode] = useState(false);
+    const [searchQuery, setSearchQuery] = useState('');
+    const [selectedIndex, setSelectedIndex] = useState(0);
+    const { onEscape, onEnter, skipInTest = true, isDisabled = false } = options;
+    // Reset selected index when items change in search mode
+    useEffect(() => {
+        if (isSearchMode && selectedIndex >= itemsLength) {
+            setSelectedIndex(Math.max(0, itemsLength - 1));
+        }
+    }, [itemsLength, isSearchMode, selectedIndex]);
+    // Handle keyboard input
+    useInput((input, key) => {
+        // Skip in test environment to avoid stdin.ref error
+        if (skipInTest && !process.stdin.setRawMode) {
+            return;
+        }
+        // Skip if disabled
+        if (isDisabled) {
+            return;
+        }
+        // Handle ESC key
+        if (key.escape) {
+            if (isSearchMode) {
+                // Exit search mode but keep filter
+                setIsSearchMode(false);
+                onEscape?.();
+            }
+            else {
+                // Clear filter when not in search mode
+                setSearchQuery('');
+            }
+            return;
+        }
+        // Handle Enter key in search mode to exit search mode but keep filter
+        if (key.return && isSearchMode) {
+            setIsSearchMode(false);
+            onEnter?.();
+            return;
+        }
+        // Handle arrow keys in search mode for navigation
+        if (isSearchMode) {
+            if (key.upArrow && selectedIndex > 0) {
+                setSelectedIndex(selectedIndex - 1);
+            }
+            else if (key.downArrow && selectedIndex < itemsLength - 1) {
+                setSelectedIndex(selectedIndex + 1);
+            }
+            return;
+        }
+        // Handle "/" key to enter search mode
+        if (input === '/') {
+            setIsSearchMode(true);
+            setSelectedIndex(0);
+            return;
+        }
+    }, { isActive: !isDisabled });
+    return {
+        isSearchMode,
+        searchQuery,
+        selectedIndex,
+        setSearchQuery,
+        setSelectedIndex,
+    };
+}

package/dist/services/configurationManager.d.ts

@@ -2,6 +2,7 @@ import { ConfigurationData, StatusHookConfig, ShortcutConfig, WorktreeConfig, Co
 export declare class ConfigurationManager {
     private configPath;
     private legacyShortcutsPath;
+    private configDir;
     private config;
     constructor();
     private loadConfig;

package/dist/services/configurationManager.js

@@ -16,6 +16,12 @@ export class ConfigurationManager {
             writable: true,
             value: void 0
         });
+        Object.defineProperty(this, "configDir", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
         Object.defineProperty(this, "config", {
             enumerable: true,
             configurable: true,
@@ -24,15 +30,16 @@ export class ConfigurationManager {
         });
         // Determine config directory based on platform
         const homeDir = homedir();
-        const configDir = process.platform === 'win32'
-            ? join(process.env['APPDATA'] || join(homeDir, 'AppData', 'Roaming'), 'ccmanager')
-            : join(homeDir, '.config', 'ccmanager');
+        this.configDir =
+            process.platform === 'win32'
+                ? join(process.env['APPDATA'] || join(homeDir, 'AppData', 'Roaming'), 'ccmanager')
+                : join(homeDir, '.config', 'ccmanager');
         // Ensure config directory exists
-        if (!existsSync(configDir)) {
-            mkdirSync(configDir, { recursive: true });
+        if (!existsSync(this.configDir)) {
+            mkdirSync(this.configDir, { recursive: true });
         }
-        this.configPath = join(configDir, 'config.json');
-        this.legacyShortcutsPath = join(configDir, 'shortcuts.json');
+        this.configPath = join(this.configDir, 'config.json');
+        this.legacyShortcutsPath = join(this.configDir, 'shortcuts.json');
         this.loadConfig();
     }
     loadConfig() {

package/dist/services/globalSessionOrchestrator.d.ts

@@ -0,0 +1,16 @@
+import { SessionManager } from './sessionManager.js';
+import { Session } from '../types/index.js';
+declare class GlobalSessionOrchestrator {
+    private static instance;
+    private projectManagers;
+    private globalManager;
+    private constructor();
+    static getInstance(): GlobalSessionOrchestrator;
+    getManagerForProject(projectPath?: string): SessionManager;
+    getAllActiveSessions(): Session[];
+    destroyAllSessions(): void;
+    destroyProjectSessions(projectPath: string): void;
+    getProjectSessions(projectPath: string): Session[];
+}
+export declare const globalSessionOrchestrator: GlobalSessionOrchestrator;
+export {};