ccmanager 3.8.1 → 3.10.0

package/dist/components/App.js

@@ -3,7 +3,7 @@ import { useState, useEffect, useCallback } from 'react';
 import { useApp, Box, Text } from 'ink';
 import { Effect } from 'effect';
 import Menu from './Menu.js';
-import ProjectList from './ProjectList.js';
+import Dashboard from './Dashboard.js';
 import Session from './Session.js';
 import NewWorktree from './NewWorktree.js';
 import DeleteWorktree from './DeleteWorktree.js';
@@ -363,6 +363,15 @@ const App = ({ devcontainerConfig, multiProject, version, }) => {
         projectManager.addRecentProject(project);
         navigateWithClear('menu');
     };
+    const handleSelectSessionFromDashboard = (session, project) => {
+        // Set the correct session manager for this project
+        const projectSessionManager = globalSessionOrchestrator.getManagerForProject(project.path);
+        setSessionManager(projectSessionManager);
+        setWorktreeService(new WorktreeService(project.path));
+        // Don't set selectedProject so session exit returns to Dashboard
+        setActiveSession(session);
+        navigateWithClear('session');
+    };
     const handleBackToProjectList = () => {
         // Sessions persist in their project-specific managers
         setSelectedProject(null);
@@ -378,7 +387,7 @@ const App = ({ devcontainerConfig, multiProject, version, }) => {
         if (!projectsDir) {
             return (_jsx(Box, { children: _jsxs(Text, { color: "red", children: ["Error: ", MULTI_PROJECT_ERRORS.NO_PROJECTS_DIR] }) }));
         }
-        return (_jsx(ProjectList, { projectsDir: projectsDir, onSelectProject: handleSelectProject, error: error, onDismissError: () => setError(null) }));
+        return (_jsx(Dashboard, { projectsDir: projectsDir, onSelectSession: handleSelectSessionFromDashboard, onSelectProject: handleSelectProject, error: error, onDismissError: () => setError(null), version: version }));
     }
     if (view === 'menu') {
         return (_jsx(Menu, { sessionManager: sessionManager, worktreeService: worktreeService, onSelectWorktree: handleSelectWorktree, onSelectRecentProject: handleSelectProject, error: error, onDismissError: () => setError(null), projectName: selectedProject?.name, multiProject: multiProject, version: version }, menuKey));

package/dist/components/App.test.js

@@ -54,6 +54,8 @@ vi.mock('../services/globalSessionOrchestrator.js', () => ({
     globalSessionOrchestrator: {
         getManagerForProject: getManagerForProjectMock,
         destroyAllSessions: vi.fn(),
+        getProjectPaths: vi.fn(() => []),
+        getProjectSessions: vi.fn(() => []),
     },
 }));
 vi.mock('../services/projectManager.js', () => ({
@@ -71,7 +73,7 @@ vi.mock('../services/worktreeService.js', () => ({
     }),
 }));
 vi.mock('./Menu.js', createInkMock('Menu View', props => (menuProps = props)));
-vi.mock('./ProjectList.js', createInkMock('Project List View', () => { }));
+vi.mock('./Dashboard.js', createInkMock('Dashboard View', () => { }));
 vi.mock('./NewWorktree.js', createInkMock('New Worktree View', props => {
     newWorktreeProps = props;
 }));
@@ -139,7 +141,7 @@ describe('App component view state', () => {
         process.env[ENV_VARS.MULTI_PROJECT_ROOT] = '/tmp/projects';
         const { lastFrame, unmount } = render(_jsx(App, { multiProject: true, version: "test" }));
         await flush();
-        expect(lastFrame()).toContain('Project List View');
+        expect(lastFrame()).toContain('Dashboard View');
         unmount();
         if (original !== undefined) {
             process.env[ENV_VARS.MULTI_PROJECT_ROOT] = original;

package/dist/components/Configuration.js

@@ -7,6 +7,7 @@ import ConfigureStatusHooks from './ConfigureStatusHooks.js';
 import ConfigureWorktreeHooks from './ConfigureWorktreeHooks.js';
 import ConfigureWorktree from './ConfigureWorktree.js';
 import ConfigureCommand from './ConfigureCommand.js';
+import ConfigureMerge from './ConfigureMerge.js';
 import ConfigureOther from './ConfigureOther.js';
 import { shortcutManager } from '../services/shortcutManager.js';
 import { ConfigEditorProvider } from '../contexts/ConfigEditorContext.js';
@@ -34,6 +35,10 @@ const ConfigurationContent = ({ scope, onComplete }) => {
             label: 'C 🚀  Configure Command Presets',
             value: 'presets',
         },
+        {
+            label: 'M 🔀  Configure Merge/Rebase',
+            value: 'mergeConfig',
+        },
         {
             label: 'O 🧪  Other & Experimental',
             value: 'other',
@@ -62,6 +67,9 @@ const ConfigurationContent = ({ scope, onComplete }) => {
         else if (item.value === 'presets') {
             setView('presets');
         }
+        else if (item.value === 'mergeConfig') {
+            setView('mergeConfig');
+        }
         else if (item.value === 'other') {
             setView('other');
         }
@@ -90,6 +98,9 @@ const ConfigurationContent = ({ scope, onComplete }) => {
             case 'c':
                 setView('presets');
                 break;
+            case 'm':
+                setView('mergeConfig');
+                break;
             case 'o':
                 setView('other');
                 break;
@@ -117,6 +128,9 @@ const ConfigurationContent = ({ scope, onComplete }) => {
     if (view === 'presets') {
         return _jsx(ConfigureCommand, { onComplete: handleSubMenuComplete });
     }
+    if (view === 'mergeConfig') {
+        return _jsx(ConfigureMerge, { onComplete: handleSubMenuComplete });
+    }
     if (view === 'other') {
         return _jsx(ConfigureOther, { onComplete: handleSubMenuComplete });
     }

package/dist/components/ConfigureMerge.d.ts

@@ -0,0 +1,6 @@
+import React from 'react';
+interface ConfigureMergeProps {
+    onComplete: () => void;
+}
+declare const ConfigureMerge: React.FC<ConfigureMergeProps>;
+export default ConfigureMerge;

package/dist/components/ConfigureMerge.js

@@ -0,0 +1,81 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { useState } from 'react';
+import { Box, Text, useInput } from 'ink';
+import SelectInput from 'ink-select-input';
+import TextInputWrapper from './TextInputWrapper.js';
+import { useConfigEditor } from '../contexts/ConfigEditorContext.js';
+import { shortcutManager } from '../services/shortcutManager.js';
+const DEFAULT_MERGE_ARGS = ['--no-ff'];
+const DEFAULT_REBASE_ARGS = [];
+const ConfigureMerge = ({ onComplete }) => {
+    const configEditor = useConfigEditor();
+    const scope = configEditor.getScope();
+    const currentConfig = configEditor.getMergeConfig() || {};
+    const [mergeConfig, setMergeConfig] = useState(currentConfig);
+    const [editField, setEditField] = useState(null);
+    const [inputValue, setInputValue] = useState('');
+    const isInheriting = scope === 'project' && !configEditor.hasProjectOverride('mergeConfig');
+    const getMergeArgs = () => mergeConfig.mergeArgs ?? DEFAULT_MERGE_ARGS;
+    const getRebaseArgs = () => mergeConfig.rebaseArgs ?? DEFAULT_REBASE_ARGS;
+    const formatArgs = (args) => args.length > 0 ? args.join(' ') : '(none)';
+    const menuItems = [
+        {
+            label: `Merge Arguments: ${formatArgs(getMergeArgs())}`,
+            value: 'mergeArgs',
+        },
+        {
+            label: `Rebase Arguments: ${formatArgs(getRebaseArgs())}`,
+            value: 'rebaseArgs',
+        },
+        { label: '-----', value: 'separator' },
+        { label: '<- Back', value: 'back' },
+    ];
+    const handleSelect = (item) => {
+        if (item.value === 'separator')
+            return;
+        if (item.value === 'back') {
+            onComplete();
+            return;
+        }
+        const field = item.value;
+        setEditField(field);
+        switch (field) {
+            case 'mergeArgs':
+                setInputValue(getMergeArgs().join(' '));
+                break;
+            case 'rebaseArgs':
+                setInputValue(getRebaseArgs().join(' '));
+                break;
+        }
+    };
+    const handleFieldUpdate = (value) => {
+        const args = value.trim() ? value.trim().split(/\s+/) : [];
+        const updated = { ...mergeConfig, [editField]: args };
+        setMergeConfig(updated);
+        configEditor.setMergeConfig(updated);
+        setEditField(null);
+        setInputValue('');
+    };
+    useInput((input, key) => {
+        if (shortcutManager.matchesShortcut('cancel', input, key)) {
+            if (editField) {
+                setEditField(null);
+                setInputValue('');
+            }
+            else {
+                onComplete();
+            }
+            return;
+        }
+    });
+    if (editField) {
+        const titles = {
+            mergeArgs: 'Enter merge arguments (space-separated, default: --no-ff):',
+            rebaseArgs: 'Enter rebase arguments (space-separated, default: none):',
+        };
+        return (_jsxs(Box, { flexDirection: "column", children: [_jsx(Box, { marginBottom: 1, children: _jsx(Text, { bold: true, color: "green", children: "Edit Merge Config" }) }), _jsx(Box, { marginBottom: 1, children: _jsx(Text, { children: titles[editField] }) }), _jsx(Box, { children: _jsx(TextInputWrapper, { value: inputValue, onChange: setInputValue, onSubmit: handleFieldUpdate, placeholder: "e.g., --no-ff or leave empty" }) }), _jsx(Box, { marginTop: 1, children: _jsxs(Text, { dimColor: true, children: ["Press Enter to save, ", shortcutManager.getShortcutDisplay('cancel'), ' ', "to cancel"] }) })] }));
+    }
+    const scopeLabel = scope === 'project' ? 'Project' : 'Global';
+    return (_jsxs(Box, { flexDirection: "column", children: [_jsx(Box, { marginBottom: 1, children: _jsxs(Text, { bold: true, color: "green", children: ["Configure Merge/Rebase (", scopeLabel, ")"] }) }), isInheriting && (_jsx(Box, { marginBottom: 1, children: _jsxs(Text, { backgroundColor: "cyan", color: "black", children: [' ', "Inheriting from global configuration", ' '] }) })), _jsx(Box, { marginBottom: 1, children: _jsx(Text, { dimColor: true, children: "Configure arguments for merge and rebase operations" }) }), _jsx(SelectInput, { items: menuItems, onSelect: handleSelect }), _jsx(Box, { marginTop: 1, children: _jsxs(Text, { dimColor: true, children: ["Press Enter to edit, ", shortcutManager.getShortcutDisplay('cancel'), " to go back"] }) })] }));
+};
+export default ConfigureMerge;

package/dist/components/Dashboard.d.ts

@@ -0,0 +1,12 @@
+import React from 'react';
+import { GitProject, Session as ISession } from '../types/index.js';
+interface DashboardProps {
+    projectsDir: string;
+    onSelectSession: (session: ISession, project: GitProject) => void;
+    onSelectProject: (project: GitProject) => void;
+    error: string | null;
+    onDismissError: () => void;
+    version: string;
+}
+declare const Dashboard: React.FC<DashboardProps>;
+export default Dashboard;

package/dist/components/Dashboard.js

@@ -0,0 +1,443 @@
+import { jsxs as _jsxs, jsx as _jsx } from "react/jsx-runtime";
+import { useState, useEffect, useMemo } from 'react';
+import { Box, Text, useInput, useStdout } from 'ink';
+import { Effect } from 'effect';
+import SelectInput from 'ink-select-input';
+import stripAnsi from 'strip-ansi';
+import { projectManager } from '../services/projectManager.js';
+import { globalSessionOrchestrator } from '../services/globalSessionOrchestrator.js';
+import { SessionManager } from '../services/sessionManager.js';
+import { WorktreeService } from '../services/worktreeService.js';
+import { STATUS_ICONS, STATUS_LABELS, MENU_ICONS, getStatusDisplay, } from '../constants/statusIcons.js';
+import { useSearchMode } from '../hooks/useSearchMode.js';
+import { useGitStatus } from '../hooks/useGitStatus.js';
+import { truncateString, calculateColumnPositions, assembleWorktreeLabel, } from '../utils/worktreeUtils.js';
+import { formatGitFileChanges, formatGitAheadBehind, formatParentBranch, } from '../utils/gitStatus.js';
+import TextInputWrapper from './TextInputWrapper.js';
+const MAX_BRANCH_NAME_LENGTH = 70;
+const createSeparatorWithText = (text, totalWidth = 35) => {
+    const textWithSpaces = ` ${text} `;
+    const textLength = textWithSpaces.length;
+    const remainingWidth = totalWidth - textLength;
+    const leftDashes = Math.floor(remainingWidth / 2);
+    const rightDashes = Math.ceil(remainingWidth / 2);
+    return '─'.repeat(leftDashes) + textWithSpaces + '─'.repeat(rightDashes);
+};
+const formatErrorMessage = (error) => {
+    switch (error._tag) {
+        case 'ProcessError':
+            return `Process error: ${error.message}`;
+        case 'ConfigError':
+            return `Configuration error (${error.reason}): ${error.details}`;
+        case 'GitError':
+            return `Git command failed: ${error.command} (exit ${error.exitCode})\n${error.stderr}`;
+        case 'FileSystemError':
+            return `File ${error.operation} failed for ${error.path}: ${error.cause}`;
+        case 'ValidationError':
+            return `Validation failed for ${error.field}: ${error.constraint}`;
+    }
+};
+/** Sort sessions: busy first, then waiting/pending, then idle. Within same state, by lastActivity desc. */
+function sessionSortKey(session) {
+    const stateData = session.stateMutex.getSnapshot();
+    switch (stateData.state) {
+        case 'busy':
+            return 0;
+        case 'waiting_input':
+        case 'pending_auto_approval':
+            return 1;
+        case 'idle':
+            return 2;
+    }
+}
+/** Resolve the display name for a project, using relativePath if names collide. */
+function resolveProjectDisplayNames(projects) {
+    const nameCount = new Map();
+    for (const p of projects) {
+        nameCount.set(p.name, (nameCount.get(p.name) || 0) + 1);
+    }
+    const displayNames = new Map();
+    for (const p of projects) {
+        displayNames.set(p.path, nameCount.get(p.name) > 1 ? p.relativePath : p.name);
+    }
+    return displayNames;
+}
+const Dashboard = ({ projectsDir, onSelectSession, onSelectProject, error, onDismissError, version, }) => {
+    const [projects, setProjects] = useState([]);
+    const [recentProjects, setRecentProjects] = useState([]);
+    const [loading, setLoading] = useState(true);
+    const [loadError, setLoadError] = useState(null);
+    const [items, setItems] = useState([]);
+    // Session-related state
+    const [sessionEntries, setSessionEntries] = useState([]);
+    const [baseSessionWorktrees, setBaseSessionWorktrees] = useState([]);
+    const [sessionRefreshKey, setSessionRefreshKey] = useState(0);
+    const { stdout } = useStdout();
+    const fixedRows = 6;
+    const displayError = error || loadError;
+    const { isSearchMode, searchQuery, selectedIndex, setSearchQuery } = useSearchMode(items.length, {
+        isDisabled: !!displayError,
+        skipInTest: false,
+    });
+    const limit = Math.max(5, stdout.rows - fixedRows - (isSearchMode ? 1 : 0) - (displayError ? 3 : 0));
+    // Git status polling for session worktrees
+    const enrichedWorktrees = useGitStatus(baseSessionWorktrees, baseSessionWorktrees.length > 0 ? 'main' : null);
+    // Discover projects on mount
+    useEffect(() => {
+        let cancelled = false;
+        const loadProjects = async () => {
+            setLoading(true);
+            setLoadError(null);
+            const result = await Effect.runPromise(Effect.either(projectManager.instance.discoverProjectsEffect(projectsDir)));
+            if (cancelled)
+                return;
+            if (result._tag === 'Left') {
+                setLoadError(formatErrorMessage(result.left));
+                setLoading(false);
+                return;
+            }
+            setProjects(result.right);
+            setRecentProjects(projectManager.getRecentProjects(0));
+            setLoading(false);
+        };
+        loadProjects();
+        return () => {
+            cancelled = true;
+        };
+    }, [projectsDir]);
+    // Load session worktree data on mount + sessionRefreshKey
+    useEffect(() => {
+        let cancelled = false;
+        const loadSessionData = async () => {
+            const projectPaths = globalSessionOrchestrator.getProjectPaths();
+            const entries = [];
+            const worktrees = [];
+            // Build a project lookup map
+            const projectByPath = new Map();
+            for (const p of projects) {
+                projectByPath.set(p.path, p);
+            }
+            const displayNames = resolveProjectDisplayNames(projects);
+            for (const projectPath of projectPaths) {
+                const sessions = globalSessionOrchestrator.getProjectSessions(projectPath);
+                if (sessions.length === 0)
+                    continue;
+                // Load worktrees for this project to resolve branch names
+                const ws = new WorktreeService(projectPath);
+                const result = await Effect.runPromise(Effect.either(ws.getWorktreesEffect()));
+                if (cancelled)
+                    return;
+                if (result._tag === 'Left')
+                    continue;
+                const projectWorktrees = result.right;
+                const project = projectByPath.get(projectPath);
+                const projectName = displayNames.get(projectPath) ||
+                    project?.name ||
+                    projectPath.split('/').pop() ||
+                    projectPath;
+                // Mark worktrees that have sessions
+                for (const wt of projectWorktrees) {
+                    wt.hasSession = sessions.some(s => s.worktreePath === wt.path);
+                }
+                for (const session of sessions) {
+                    const wt = projectWorktrees.find(w => w.path === session.worktreePath);
+                    if (!wt)
+                        continue;
+                    entries.push({
+                        session,
+                        projectPath,
+                        projectName,
+                        worktree: wt,
+                    });
+                    worktrees.push(wt);
+                }
+            }
+            if (cancelled)
+                return;
+            // Sort sessions: busy > waiting > idle, then by lastActivity desc
+            entries.sort((a, b) => {
+                const keyA = sessionSortKey(a.session);
+                const keyB = sessionSortKey(b.session);
+                if (keyA !== keyB)
+                    return keyA - keyB;
+                return (b.session.lastActivity.getTime() - a.session.lastActivity.getTime());
+            });
+            setSessionEntries(entries);
+            setBaseSessionWorktrees(prev => {
+                // Avoid restarting git status polling if the set of paths hasn't changed
+                const prevPaths = prev
+                    .map(w => w.path)
+                    .sort()
+                    .join('\0');
+                const newPaths = worktrees
+                    .map(w => w.path)
+                    .sort()
+                    .join('\0');
+                return prevPaths === newPaths ? prev : worktrees;
+            });
+        };
+        loadSessionData();
+        return () => {
+            cancelled = true;
+        };
+    }, [sessionRefreshKey, projects]);
+    // Subscribe to session events from all managers
+    useEffect(() => {
+        const refresh = () => setSessionRefreshKey(k => k + 1);
+        const projectPaths = globalSessionOrchestrator.getProjectPaths();
+        const managers = projectPaths.map(p => globalSessionOrchestrator.getManagerForProject(p));
+        for (const mgr of managers) {
+            mgr.on('sessionCreated', refresh);
+            mgr.on('sessionDestroyed', refresh);
+            mgr.on('sessionStateChanged', refresh);
+        }
+        return () => {
+            for (const mgr of managers) {
+                mgr.off('sessionCreated', refresh);
+                mgr.off('sessionDestroyed', refresh);
+                mgr.off('sessionStateChanged', refresh);
+            }
+        };
+    }, [sessionRefreshKey]);
+    // Build display items
+    const projectDisplayNames = useMemo(() => resolveProjectDisplayNames(projects), [projects]);
+    useEffect(() => {
+        const menuItems = [];
+        let currentIndex = 0;
+        // --- Active Sessions section ---
+        if (sessionEntries.length > 0) {
+            // Build WorktreeItems for column alignment
+            const sessionWorkItems = sessionEntries.map(entry => {
+                // Use enriched worktree if available (has git status)
+                const wt = enrichedWorktrees.find(w => w.path === entry.worktree.path) ||
+                    entry.worktree;
+                const stateData = entry.session.stateMutex.getSnapshot();
+                const status = ` [${getStatusDisplay(stateData.state, stateData.backgroundTaskCount, stateData.teamMemberCount)}]`;
+                const fullBranchName = wt.branch
+                    ? wt.branch.replace('refs/heads/', '')
+                    : wt.path.split('/').pop() || 'detached';
+                const branchName = truncateString(fullBranchName, MAX_BRANCH_NAME_LENGTH);
+                const isMain = wt.isMainWorktree ? ' (main)' : '';
+                const baseLabel = `${entry.projectName} :: ${branchName}${isMain}${status}`;
+                let fileChanges = '';
+                let aheadBehind = '';
+                let parentBranch = '';
+                let itemError = '';
+                if (wt.gitStatus) {
+                    fileChanges = formatGitFileChanges(wt.gitStatus);
+                    aheadBehind = formatGitAheadBehind(wt.gitStatus);
+                    parentBranch = formatParentBranch(wt.gitStatus.parentBranch, fullBranchName);
+                }
+                else if (wt.gitStatusError) {
+                    itemError = `\x1b[31m[git error]\x1b[0m`;
+                }
+                else {
+                    fileChanges = '\x1b[90m[fetching...]\x1b[0m';
+                }
+                return {
+                    worktree: wt,
+                    session: entry.session,
+                    baseLabel,
+                    fileChanges,
+                    aheadBehind,
+                    parentBranch,
+                    error: itemError,
+                    lengths: {
+                        base: stripAnsi(baseLabel).length,
+                        fileChanges: stripAnsi(fileChanges).length,
+                        aheadBehind: stripAnsi(aheadBehind).length,
+                        parentBranch: stripAnsi(parentBranch).length,
+                    },
+                };
+            });
+            const columns = calculateColumnPositions(sessionWorkItems);
+            if (!isSearchMode) {
+                menuItems.push({
+                    type: 'common',
+                    label: createSeparatorWithText('Active Sessions'),
+                    value: 'separator-sessions',
+                });
+            }
+            // Filter by search query
+            const filteredEntries = searchQuery
+                ? sessionEntries.filter((_entry, i) => {
+                    const item = sessionWorkItems[i];
+                    return stripAnsi(item.baseLabel)
+                        .toLowerCase()
+                        .includes(searchQuery.toLowerCase());
+                })
+                : sessionEntries;
+            filteredEntries.forEach(entry => {
+                const itemIndex = sessionEntries.indexOf(entry);
+                const workItem = sessionWorkItems[itemIndex];
+                const label = assembleWorktreeLabel(workItem, columns);
+                const numberPrefix = !isSearchMode && currentIndex < 10 ? `${currentIndex} ❯ ` : '❯ ';
+                const project = {
+                    path: entry.projectPath,
+                    name: entry.projectName,
+                    relativePath: projects.find(p => p.path === entry.projectPath)?.relativePath ||
+                        entry.projectPath,
+                    isValid: true,
+                };
+                menuItems.push({
+                    type: 'session',
+                    label: numberPrefix + label,
+                    value: `session-${entry.session.id}`,
+                    session: entry.session,
+                    project,
+                });
+                currentIndex++;
+            });
+        }
+        // --- Projects section ---
+        const filteredRecentProjects = searchQuery
+            ? recentProjects.filter(p => p.name.toLowerCase().includes(searchQuery.toLowerCase()))
+            : recentProjects;
+        const filteredProjects = searchQuery
+            ? projects.filter(p => p.name.toLowerCase().includes(searchQuery.toLowerCase()))
+            : projects;
+        // Deduplicate: recent projects first, then remaining
+        const recentPaths = new Set(filteredRecentProjects.map(rp => rp.path));
+        const nonRecentProjects = filteredProjects.filter(p => !recentPaths.has(p.path));
+        // Build ordered project list: recent first, then alphabetical
+        const orderedProjects = [];
+        for (const rp of filteredRecentProjects) {
+            const full = projects.find(p => p.path === rp.path);
+            if (full)
+                orderedProjects.push(full);
+        }
+        orderedProjects.push(...nonRecentProjects);
+        if (orderedProjects.length > 0 && !isSearchMode) {
+            menuItems.push({
+                type: 'common',
+                label: createSeparatorWithText('Projects'),
+                value: 'separator-projects',
+            });
+        }
+        orderedProjects.forEach(project => {
+            const projectSessions = globalSessionOrchestrator.getProjectSessions(project.path);
+            const counts = SessionManager.getSessionCounts(projectSessions);
+            const countsFormatted = SessionManager.formatSessionCounts(counts);
+            const displayName = projectDisplayNames.get(project.path) || project.name;
+            const numberPrefix = !isSearchMode && currentIndex < 10 ? `${currentIndex} ❯ ` : '❯ ';
+            menuItems.push({
+                type: 'project',
+                label: numberPrefix + displayName + countsFormatted,
+                value: project.path,
+                project,
+            });
+            currentIndex++;
+        });
+        // --- Other section ---
+        if (!isSearchMode) {
+            menuItems.push({
+                type: 'common',
+                label: createSeparatorWithText('Other'),
+                value: 'separator-other',
+            });
+            menuItems.push({
+                type: 'common',
+                label: `R 🔄 Refresh`,
+                value: 'refresh',
+            });
+            menuItems.push({
+                type: 'common',
+                label: `Q ${MENU_ICONS.EXIT} Exit`,
+                value: 'exit',
+            });
+        }
+        setItems(menuItems);
+    }, [
+        sessionEntries,
+        enrichedWorktrees,
+        projects,
+        recentProjects,
+        projectDisplayNames,
+        searchQuery,
+        isSearchMode,
+    ]);
+    // Refresh handler
+    const refreshAll = () => {
+        setLoading(true);
+        setLoadError(null);
+        Effect.runPromise(Effect.either(projectManager.instance.discoverProjectsEffect(projectsDir))).then(result => {
+            if (result._tag === 'Left') {
+                setLoadError(formatErrorMessage(result.left));
+                setLoading(false);
+                return;
+            }
+            setProjects(result.right);
+            setRecentProjects(projectManager.getRecentProjects(0));
+            setLoading(false);
+            setSessionRefreshKey(k => k + 1);
+        });
+    };
+    // Handle hotkeys
+    useInput((input, _key) => {
+        if (!process.stdin.setRawMode)
+            return;
+        if (displayError && onDismissError) {
+            onDismissError();
+            return;
+        }
+        if (isSearchMode)
+            return;
+        const keyPressed = input.toLowerCase();
+        // Number keys 0-9 for quick selection
+        if (/^[0-9]$/.test(keyPressed)) {
+            const index = parseInt(keyPressed);
+            const selectableItems = items.filter(item => item.type === 'session' || item.type === 'project');
+            if (index < selectableItems.length && selectableItems[index]) {
+                const selected = selectableItems[index];
+                if (selected.type === 'session') {
+                    onSelectSession(selected.session, selected.project);
+                }
+                else if (selected.type === 'project') {
+                    onSelectProject(selected.project);
+                }
+            }
+            return;
+        }
+        switch (keyPressed) {
+            case 'r':
+                refreshAll();
+                break;
+            case 'q':
+            case 'x':
+                onSelectProject({
+                    path: 'EXIT_APPLICATION',
+                    name: '',
+                    relativePath: '',
+                    isValid: false,
+                });
+                break;
+        }
+    });
+    const handleSelect = (item) => {
+        if (item.value.startsWith('separator'))
+            return;
+        if (item.type === 'session') {
+            onSelectSession(item.session, item.project);
+        }
+        else if (item.type === 'project') {
+            onSelectProject(item.project);
+        }
+        else if (item.value === 'refresh') {
+            refreshAll();
+        }
+        else if (item.value === 'exit') {
+            onSelectProject({
+                path: 'EXIT_APPLICATION',
+                name: '',
+                relativePath: '',
+                isValid: false,
+            });
+        }
+    };
+    return (_jsxs(Box, { flexDirection: "column", children: [_jsx(Box, { marginBottom: 1, flexDirection: "column", children: _jsxs(Text, { bold: true, color: "green", children: ["CCManager - Dashboard v", version] }) }), isSearchMode && (_jsxs(Box, { marginBottom: 1, children: [_jsx(Text, { children: "Search: " }), _jsx(TextInputWrapper, { value: searchQuery, onChange: setSearchQuery, focus: true, placeholder: "Type to filter..." })] })), loading ? (_jsx(Box, { children: _jsx(Text, { color: "yellow", children: "Discovering projects..." }) })) : projects.length === 0 && !displayError ? (_jsx(Box, { children: _jsxs(Text, { color: "yellow", children: ["No git repositories found in ", projectsDir] }) })) : isSearchMode && items.length === 0 ? (_jsx(Box, { children: _jsx(Text, { color: "yellow", children: "No matches found" }) })) : isSearchMode ? (_jsx(Box, { flexDirection: "column", children: items.slice(0, limit).map((item, index) => (_jsxs(Text, { color: index === selectedIndex ? 'green' : undefined, children: [index === selectedIndex ? '❯ ' : '  ', item.label] }, item.value))) })) : (_jsx(SelectInput, { items: items, onSelect: item => handleSelect(item), isFocused: !displayError, limit: limit, initialIndex: selectedIndex })), displayError && (_jsx(Box, { marginTop: 1, paddingX: 1, borderStyle: "round", borderColor: "red", children: _jsxs(Box, { flexDirection: "column", children: [_jsxs(Text, { color: "red", bold: true, children: ["Error: ", displayError] }), _jsx(Text, { color: "gray", dimColor: true, children: "Press any key to dismiss" })] }) })), _jsxs(Box, { marginTop: 1, flexDirection: "column", children: [_jsxs(Text, { dimColor: true, children: ["Status: ", STATUS_ICONS.BUSY, " ", STATUS_LABELS.BUSY, ' ', STATUS_ICONS.WAITING, " ", STATUS_LABELS.WAITING, " ", STATUS_ICONS.IDLE, ' ', STATUS_LABELS.IDLE] }), _jsx(Text, { dimColor: true, children: 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 Dashboard;