ccmanager 3.5.0 → 3.5.2

package/dist/components/DeleteWorktree.js

@@ -1,4 +1,5 @@
-import React, { useState, useEffect } from 'react';
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { useState, useEffect } from 'react';
 import { Box, Text, useInput } from 'ink';
 import SelectInput from 'ink-select-input';
 import { Effect } from 'effect';
@@ -80,25 +81,13 @@ const DeleteWorktree = ({ projectPath, onComplete, onCancel, }) => {
         }
     });
     if (isLoading) {
-        return (React.createElement(Box, { flexDirection: "column" },
-            React.createElement(Text, { color: "cyan" }, "Loading worktrees...")));
+        return (_jsx(Box, { flexDirection: "column", children: _jsx(Text, { color: "cyan", children: "Loading worktrees..." }) }));
     }
     if (error) {
-        return (React.createElement(Box, { flexDirection: "column" },
-            React.createElement(Text, { color: "red" }, "Error loading worktrees:"),
-            React.createElement(Text, { color: "red" }, error),
-            React.createElement(Text, { dimColor: true },
-                "Press ",
-                shortcutManager.getShortcutDisplay('cancel'),
-                " to return to menu")));
+        return (_jsxs(Box, { flexDirection: "column", children: [_jsx(Text, { color: "red", children: "Error loading worktrees:" }), _jsx(Text, { color: "red", children: error }), _jsxs(Text, { dimColor: true, children: ["Press ", shortcutManager.getShortcutDisplay('cancel'), " to return to menu"] })] }));
     }
     if (worktrees.length === 0) {
-        return (React.createElement(Box, { flexDirection: "column" },
-            React.createElement(Text, { color: "yellow" }, "No worktrees available to delete."),
-            React.createElement(Text, { dimColor: true },
-                "Press ",
-                shortcutManager.getShortcutDisplay('cancel'),
-                " to return to menu")));
+        return (_jsxs(Box, { flexDirection: "column", children: [_jsx(Text, { color: "yellow", children: "No worktrees available to delete." }), _jsxs(Text, { dimColor: true, children: ["Press ", shortcutManager.getShortcutDisplay('cancel'), " to return to menu"] })] }));
     }
     if (confirmMode) {
         const selectedWorktrees = Array.from(selectedIndices).map(index => worktrees[index]);
@@ -109,32 +98,15 @@ const DeleteWorktree = ({ projectPath, onComplete, onCancel, }) => {
         const handleCancel = () => {
             setConfirmMode(false);
         };
-        return (React.createElement(DeleteConfirmation, { worktrees: selectedWorktrees, onConfirm: handleConfirm, onCancel: handleCancel }));
+        return (_jsx(DeleteConfirmation, { worktrees: selectedWorktrees, onConfirm: handleConfirm, onCancel: handleCancel }));
     }
-    return (React.createElement(Box, { flexDirection: "column" },
-        React.createElement(Box, { marginBottom: 1 },
-            React.createElement(Text, { bold: true, color: "red" }, "Delete Worktrees")),
-        React.createElement(Box, { marginBottom: 1 },
-            React.createElement(Text, { dimColor: true }, "Select worktrees to delete (Space to select, Enter to confirm):")),
-        React.createElement(SelectInput, { items: menuItems, onSelect: handleSelect, onHighlight: (item) => {
-                const index = parseInt(item.value, 10);
-                setFocusedIndex(index);
-            }, limit: 10, indicatorComponent: ({ isSelected }) => (React.createElement(Text, { color: isSelected ? 'green' : undefined }, isSelected ? '>' : ' ')), itemComponent: ({ isSelected, label }) => {
-                // Check if this item is actually selected (checkbox checked)
-                const hasCheckmark = label.includes('[✓]');
-                return (React.createElement(Text, { color: isSelected ? 'green' : undefined, inverse: isSelected, dimColor: !isSelected && !hasCheckmark }, label));
-            } }),
-        React.createElement(Box, { marginTop: 1, flexDirection: "column" },
-            React.createElement(Text, { dimColor: true },
-                "Controls: \u2191\u2193/j/k Navigate, Space Select, Enter Confirm,",
-                ' ',
-                shortcutManager.getShortcutDisplay('cancel'),
-                " Cancel"),
-            selectedIndices.size > 0 && (React.createElement(Text, { color: "yellow" },
-                selectedIndices.size,
-                " worktree",
-                selectedIndices.size > 1 ? 's' : '',
-                ' ',
-                "selected")))));
+    return (_jsxs(Box, { flexDirection: "column", children: [_jsx(Box, { marginBottom: 1, children: _jsx(Text, { bold: true, color: "red", children: "Delete Worktrees" }) }), _jsx(Box, { marginBottom: 1, children: _jsx(Text, { dimColor: true, children: "Select worktrees to delete (Space to select, Enter to confirm):" }) }), _jsx(SelectInput, { items: menuItems, onSelect: handleSelect, onHighlight: (item) => {
+                    const index = parseInt(item.value, 10);
+                    setFocusedIndex(index);
+                }, limit: 10, indicatorComponent: ({ isSelected }) => (_jsx(Text, { color: isSelected ? 'green' : undefined, children: isSelected ? '>' : ' ' })), itemComponent: ({ isSelected, label }) => {
+                    // Check if this item is actually selected (checkbox checked)
+                    const hasCheckmark = label.includes('[✓]');
+                    return (_jsx(Text, { color: isSelected ? 'green' : undefined, inverse: isSelected, dimColor: !isSelected && !hasCheckmark, children: label }));
+                } }), _jsxs(Box, { marginTop: 1, flexDirection: "column", children: [_jsxs(Text, { dimColor: true, children: ["Controls: \u2191\u2193/j/k Navigate, Space Select, Enter Confirm,", ' ', shortcutManager.getShortcutDisplay('cancel'), " Cancel"] }), selectedIndices.size > 0 && (_jsxs(Text, { color: "yellow", children: [selectedIndices.size, " worktree", selectedIndices.size > 1 ? 's' : '', ' ', "selected"] }))] })] }));
 };
 export default DeleteWorktree;

package/dist/components/DeleteWorktree.test.js

@@ -1,4 +1,4 @@
-import React from 'react';
+import { jsx as _jsx } from "react/jsx-runtime";
 import { render } from 'ink-testing-library';
 import { describe, it, expect, vi, beforeEach } from 'vitest';
 import { Effect } from 'effect';
@@ -60,7 +60,7 @@ describe('DeleteWorktree - Effect Integration', () => {
         const onComplete = vi.fn();
         const onCancel = vi.fn();
         // WHEN: Component renders with projectPath
-        render(React.createElement(DeleteWorktree, { projectPath: projectPath, onComplete: onComplete, onCancel: onCancel }));
+        render(_jsx(DeleteWorktree, { projectPath: projectPath, onComplete: onComplete, onCancel: onCancel }));
         // Wait for Effect to execute
         await new Promise(resolve => setTimeout(resolve, 50));
         // THEN: WorktreeService was called with projectPath
@@ -85,7 +85,7 @@ describe('DeleteWorktree - Effect Integration', () => {
         const onComplete = vi.fn();
         const onCancel = vi.fn();
         // WHEN: Component renders without projectPath
-        render(React.createElement(DeleteWorktree, { onComplete: onComplete, onCancel: onCancel }));
+        render(_jsx(DeleteWorktree, { onComplete: onComplete, onCancel: onCancel }));
         // Wait for Effect to execute
         await new Promise(resolve => setTimeout(resolve, 50));
         // THEN: WorktreeService was called with undefined (defaults to cwd)
@@ -117,7 +117,7 @@ describe('DeleteWorktree - Effect Integration', () => {
         const onComplete = vi.fn();
         const onCancel = vi.fn();
         // WHEN: Component is rendered
-        const { lastFrame } = render(React.createElement(DeleteWorktree, { onComplete: onComplete, onCancel: onCancel }));
+        const { lastFrame } = render(_jsx(DeleteWorktree, { onComplete: onComplete, onCancel: onCancel }));
         // Wait for Effect to execute
         await new Promise(resolve => setTimeout(resolve, 50));
         // THEN: Effect method should be called
@@ -144,7 +144,7 @@ describe('DeleteWorktree - Effect Integration', () => {
         const onComplete = vi.fn();
         const onCancel = vi.fn();
         // WHEN: Component is rendered
-        const { lastFrame } = render(React.createElement(DeleteWorktree, { onComplete: onComplete, onCancel: onCancel }));
+        const { lastFrame } = render(_jsx(DeleteWorktree, { onComplete: onComplete, onCancel: onCancel }));
         // Wait for Effect to execute
         await new Promise(resolve => setTimeout(resolve, 50));
         // THEN: Error should be displayed
@@ -180,7 +180,7 @@ describe('DeleteWorktree - Effect Integration', () => {
         const onComplete = vi.fn();
         const onCancel = vi.fn();
         // WHEN: Component is rendered
-        const { lastFrame } = render(React.createElement(DeleteWorktree, { onComplete: onComplete, onCancel: onCancel }));
+        const { lastFrame } = render(_jsx(DeleteWorktree, { onComplete: onComplete, onCancel: onCancel }));
         // Wait for Effect to execute
         await new Promise(resolve => setTimeout(resolve, 50));
         // THEN: Only non-main worktree should be shown

package/dist/components/LoadingSpinner.js

@@ -1,4 +1,5 @@
-import React, { useState, useEffect } from 'react';
+import { jsxs as _jsxs, jsx as _jsx } from "react/jsx-runtime";
+import { useState, useEffect } from 'react';
 import { Box, Text } from 'ink';
 import { supportsUnicode } from '../utils/terminalCapabilities.js';
 const LoadingSpinner = ({ message, spinnerType, color = 'cyan', }) => {
@@ -28,10 +29,6 @@ const LoadingSpinner = ({ message, spinnerType, color = 'cyan', }) => {
         };
     }, [frames.length]);
     const currentFrame = frames[frameIndex];
-    return (React.createElement(Box, { flexDirection: "row" },
-        React.createElement(Text, { color: color },
-            currentFrame,
-            " "),
-        React.createElement(Text, null, message)));
+    return (_jsxs(Box, { flexDirection: "row", children: [_jsxs(Text, { color: color, children: [currentFrame, " "] }), _jsx(Text, { children: message })] }));
 };
 export default LoadingSpinner;

package/dist/components/LoadingSpinner.test.js

@@ -1,5 +1,5 @@
+import { jsx as _jsx } from "react/jsx-runtime";
 import { describe, it, expect, vi, afterEach } from 'vitest';
-import React from 'react';
 import { render } from 'ink-testing-library';
 import LoadingSpinner from './LoadingSpinner.js';
 describe('LoadingSpinner', () => {
@@ -19,21 +19,21 @@ describe('LoadingSpinner', () => {
     });
     describe('Core LoadingSpinner component with Unicode animation', () => {
         it('should render with default props and display message with cyan spinner', () => {
-            const { lastFrame } = render(React.createElement(LoadingSpinner, { message: "Loading..." }));
+            const { lastFrame } = render(_jsx(LoadingSpinner, { message: "Loading..." }));
             const output = lastFrame();
             expect(output).toContain('Loading...');
             // Should contain one of the Unicode spinner frames
             expect(output).toMatch(/[⠋⠙⠹⠸⠼⠴⠦⠧⠇⠏]/);
         });
         it('should render with custom color prop (yellow for devcontainer operations)', () => {
-            const { lastFrame } = render(React.createElement(LoadingSpinner, { message: "Starting devcontainer...", color: "yellow" }));
+            const { lastFrame } = render(_jsx(LoadingSpinner, { message: "Starting devcontainer...", color: "yellow" }));
             const output = lastFrame();
             expect(output).toContain('Starting devcontainer...');
             // Verify spinner is present
             expect(output).toMatch(/[⠋⠙⠹⠸⠼⠴⠦⠧⠇⠏]/);
         });
         it('should use ASCII fallback frames when spinnerType is "line"', () => {
-            const { lastFrame } = render(React.createElement(LoadingSpinner, { message: "Processing...", spinnerType: "line" }));
+            const { lastFrame } = render(_jsx(LoadingSpinner, { message: "Processing...", spinnerType: "line" }));
             const output = lastFrame();
             expect(output).toContain('Processing...');
             // Should contain one of the ASCII spinner frames
@@ -41,23 +41,23 @@ describe('LoadingSpinner', () => {
         });
         it('should set up animation interval with 120ms timing', () => {
             const setIntervalSpy = vi.spyOn(global, 'setInterval');
-            render(React.createElement(LoadingSpinner, { message: "Loading..." }));
+            render(_jsx(LoadingSpinner, { message: "Loading..." }));
             // Verify setInterval was called with 120ms timing
             expect(setIntervalSpy).toHaveBeenCalledWith(expect.any(Function), 120);
         });
         it('should cleanup interval on component unmount to prevent memory leaks', () => {
-            const { unmount } = render(React.createElement(LoadingSpinner, { message: "Loading..." }));
+            const { unmount } = render(_jsx(LoadingSpinner, { message: "Loading..." }));
             // Verify unmount completes without errors (cleanup function runs properly)
             expect(() => unmount()).not.toThrow();
         });
         it('should preserve message text', () => {
             const message = 'Creating session...';
-            const { lastFrame } = render(React.createElement(LoadingSpinner, { message: message }));
+            const { lastFrame } = render(_jsx(LoadingSpinner, { message: message }));
             // Check message is rendered
             expect(lastFrame()).toContain(message);
         });
         it('should render in flexDirection="row" layout with spinner and message', () => {
-            const { lastFrame } = render(React.createElement(LoadingSpinner, { message: "Test message" }));
+            const { lastFrame } = render(_jsx(LoadingSpinner, { message: "Test message" }));
             const output = lastFrame();
             // Verify both spinner and message are present
             // ANSI color codes may be present between spinner and message
@@ -67,45 +67,45 @@ describe('LoadingSpinner', () => {
     });
     describe('Component variations and edge cases', () => {
         it('should accept "green" color option', () => {
-            const { lastFrame } = render(React.createElement(LoadingSpinner, { message: "Success loading...", color: "green" }));
+            const { lastFrame } = render(_jsx(LoadingSpinner, { message: "Success loading...", color: "green" }));
             const output = lastFrame();
             expect(output).toContain('Success loading...');
             expect(output).toMatch(/[⠋⠙⠹⠸⠼⠴⠦⠧⠇⠏]/);
         });
         it('should render Unicode frames correctly', () => {
-            const { lastFrame } = render(React.createElement(LoadingSpinner, { message: "Test" }));
+            const { lastFrame } = render(_jsx(LoadingSpinner, { message: "Test" }));
             const output = lastFrame();
             // Should contain one of the Unicode frames
             expect(output).toMatch(/[⠋⠙⠹⠸⠼⠴⠦⠧⠇⠏]/);
         });
         it('should render ASCII frames when using "line" spinner type', () => {
-            const { lastFrame } = render(React.createElement(LoadingSpinner, { message: "Test", spinnerType: "line" }));
+            const { lastFrame } = render(_jsx(LoadingSpinner, { message: "Test", spinnerType: "line" }));
             const output = lastFrame();
             // Should contain one of the ASCII frames
             expect(output).toMatch(/[-\\|/]/);
         });
         it('should handle empty message string', () => {
-            const { lastFrame } = render(React.createElement(LoadingSpinner, { message: "" }));
+            const { lastFrame } = render(_jsx(LoadingSpinner, { message: "" }));
             const output = lastFrame();
             // Should still render spinner even with empty message
             expect(output).toMatch(/[⠋⠙⠹⠸⠼⠴⠦⠧⠇⠏]/);
         });
         it('should handle long message text without breaking layout', () => {
             const longMessage = 'This is a very long loading message that might wrap on narrow terminals';
-            const { lastFrame } = render(React.createElement(LoadingSpinner, { message: longMessage }));
+            const { lastFrame } = render(_jsx(LoadingSpinner, { message: longMessage }));
             const output = lastFrame();
             expect(output).toContain(longMessage);
             expect(output).toMatch(/[⠋⠙⠹⠸⠼⠴⠦⠧⠇⠏]/);
         });
         it('should use cyan as default color', () => {
-            const { lastFrame } = render(React.createElement(LoadingSpinner, { message: "Test" }));
+            const { lastFrame } = render(_jsx(LoadingSpinner, { message: "Test" }));
             const output = lastFrame();
             // Just verify it renders successfully with default color
             expect(output).toContain('Test');
             expect(output).toMatch(/[⠋⠙⠹⠸⠼⠴⠦⠧⠇⠏]/);
         });
         it('should use dots as default spinner type', () => {
-            const { lastFrame } = render(React.createElement(LoadingSpinner, { message: "Test" }));
+            const { lastFrame } = render(_jsx(LoadingSpinner, { message: "Test" }));
             const output = lastFrame();
             // Default should be Unicode dots, not ASCII line
             expect(output).toMatch(/[⠋⠙⠹⠸⠼⠴⠦⠧⠇⠏]/);
@@ -115,7 +115,7 @@ describe('LoadingSpinner', () => {
         it('should automatically detect Unicode support and use Unicode frames', () => {
             // Set up environment for Unicode support
             process.env['TERM'] = 'xterm-256color';
-            const { lastFrame } = render(React.createElement(LoadingSpinner, { message: "Loading..." }));
+            const { lastFrame } = render(_jsx(LoadingSpinner, { message: "Loading..." }));
             const output = lastFrame();
             // Should use Unicode frames when terminal supports it
             expect(output).toMatch(/[⠋⠙⠹⠸⠼⠴⠦⠧⠇⠏]/);
@@ -126,7 +126,7 @@ describe('LoadingSpinner', () => {
             process.env['TERM'] = 'dumb';
             delete process.env['LANG'];
             delete process.env['LC_ALL'];
-            const { lastFrame } = render(React.createElement(LoadingSpinner, { message: "Loading..." }));
+            const { lastFrame } = render(_jsx(LoadingSpinner, { message: "Loading..." }));
             const output = lastFrame();
             // Should use ASCII frames when terminal doesn't support Unicode
             expect(output).toMatch(/[-\\|/]/);
@@ -135,7 +135,7 @@ describe('LoadingSpinner', () => {
         it('should respect explicit spinnerType prop over automatic detection', () => {
             // Even with Unicode support, explicit "line" should use ASCII
             process.env['TERM'] = 'xterm-256color';
-            const { lastFrame } = render(React.createElement(LoadingSpinner, { message: "Loading...", spinnerType: "line" }));
+            const { lastFrame } = render(_jsx(LoadingSpinner, { message: "Loading...", spinnerType: "line" }));
             const output = lastFrame();
             // Explicit spinnerType should override detection
             expect(output).toMatch(/[-\\|/]/);
@@ -148,7 +148,7 @@ describe('LoadingSpinner', () => {
                 configurable: true,
             });
             process.env['WT_SESSION'] = 'some-session-id';
-            const { lastFrame } = render(React.createElement(LoadingSpinner, { message: "Loading..." }));
+            const { lastFrame } = render(_jsx(LoadingSpinner, { message: "Loading..." }));
             const output = lastFrame();
             // Should use Unicode on Windows Terminal
             expect(output).toMatch(/[⠋⠙⠹⠸⠼⠴⠦⠧⠇⠏]/);
@@ -163,7 +163,7 @@ describe('LoadingSpinner', () => {
             delete process.env['WT_SESSION'];
             delete process.env['TERM'];
             delete process.env['LANG'];
-            const { lastFrame } = render(React.createElement(LoadingSpinner, { message: "Loading..." }));
+            const { lastFrame } = render(_jsx(LoadingSpinner, { message: "Loading..." }));
             const output = lastFrame();
             // Should use ASCII on Windows without WT
             expect(output).toMatch(/[-\\|/]/);
@@ -171,7 +171,7 @@ describe('LoadingSpinner', () => {
         it('should detect Unicode support from LANG environment variable', () => {
             delete process.env['TERM'];
             process.env['LANG'] = 'en_US.UTF-8';
-            const { lastFrame } = render(React.createElement(LoadingSpinner, { message: "Loading..." }));
+            const { lastFrame } = render(_jsx(LoadingSpinner, { message: "Loading..." }));
             const output = lastFrame();
             // Should use Unicode when LANG indicates UTF-8
             expect(output).toMatch(/[⠋⠙⠹⠸⠼⠴⠦⠧⠇⠏]/);
@@ -179,7 +179,7 @@ describe('LoadingSpinner', () => {
         it('should detect Unicode support with appropriate frame rate', () => {
             process.env['TERM'] = 'xterm-256color';
             const setIntervalSpy = vi.spyOn(global, 'setInterval');
-            render(React.createElement(LoadingSpinner, { message: "Loading..." }));
+            render(_jsx(LoadingSpinner, { message: "Loading..." }));
             // Verify frame rate is 120ms regardless of detection
             expect(setIntervalSpy).toHaveBeenCalledWith(expect.any(Function), 120);
         });

package/dist/components/Menu.d.ts

@@ -11,6 +11,7 @@ interface MenuProps {
     onDismissError?: () => void;
     projectName?: string;
     multiProject?: boolean;
+    version: string;
 }
 declare const Menu: React.FC<MenuProps>;
 export default Menu;

package/dist/components/Menu.js

@@ -1,4 +1,5 @@
-import React, { useState, useEffect } from 'react';
+import { jsxs as _jsxs, jsx as _jsx } from "react/jsx-runtime";
+import { useState, useEffect } from 'react';
 import { Box, Text, useInput } from 'ink';
 import SelectInput from 'ink-select-input';
 import { Effect } from 'effect';
@@ -26,7 +27,7 @@ const createSeparatorWithText = (text, totalWidth = 35) => {
 const formatGitError = (error) => {
     return `Git command failed: ${error.command} (exit ${error.exitCode})\n${error.stderr}`;
 };
-const Menu = ({ sessionManager, worktreeService, onSelectWorktree, onSelectRecentProject, error, onDismissError, projectName, multiProject = false, }) => {
+const Menu = ({ sessionManager, worktreeService, onSelectWorktree, onSelectRecentProject, error, onDismissError, projectName, multiProject = false, version, }) => {
     const [baseWorktrees, setBaseWorktrees] = useState([]);
     const [defaultBranch, setDefaultBranch] = useState(null);
     const [loadError, setLoadError] = useState(null);
@@ -479,45 +480,12 @@ const Menu = ({ sessionManager, worktreeService, onSelectWorktree, onSelectRecen
             onSelectWorktree(item.worktree);
         }
     };
-    return (React.createElement(Box, { flexDirection: "column" },
-        React.createElement(Box, { marginBottom: 1, flexDirection: "column" },
-            React.createElement(Text, { bold: true, color: "green" }, "CCManager - Claude Code Worktree Manager"),
-            projectName && (React.createElement(Text, { bold: true, color: "green" }, projectName))),
-        React.createElement(Box, { marginBottom: 1 },
-            React.createElement(Text, { dimColor: true }, "Select a worktree to start or resume a Claude Code session:")),
-        isSearchMode && (React.createElement(Box, { marginBottom: 1 },
-            React.createElement(Text, null, "Search: "),
-            React.createElement(TextInputWrapper, { value: searchQuery, onChange: setSearchQuery, focus: true, placeholder: "Type to filter worktrees..." }))),
-        isSearchMode && items.length === 0 ? (React.createElement(Box, null,
-            React.createElement(Text, { color: "yellow" }, "No worktrees 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: item => handleSelect(item), isFocused: !error, initialIndex: selectedIndex, limit: limit })),
-        (error || loadError) && (React.createElement(Box, { marginTop: 1, paddingX: 1, borderStyle: "round", borderColor: "red" },
-            React.createElement(Box, { flexDirection: "column" },
-                React.createElement(Text, { color: "red", bold: true },
-                    "Error: ",
-                    error || loadError),
-                React.createElement(Text, { color: "gray", dimColor: true }, "Press any key to dismiss")))),
-        React.createElement(Box, { marginTop: 1, flexDirection: "column" },
-            React.createElement(Text, { dimColor: true },
-                "Status: ",
-                STATUS_ICONS.BUSY,
-                " ",
-                STATUS_LABELS.BUSY,
-                ' ',
-                STATUS_ICONS.WAITING,
-                " ",
-                STATUS_LABELS.WAITING,
-                " ",
-                STATUS_ICONS.IDLE,
-                ' ',
-                STATUS_LABELS.IDLE),
-            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 N-New M-Merge D-Delete ${multiProject ? 'C-Config' : 'P-ProjConfig C-GlobalConfig'} ${projectName ? 'B-Back' : 'Q-Quit'}`
-                    : `Controls: ↑↓ Navigate Enter Select | Hotkeys: 0-9 Quick Select /-Search N-New M-Merge D-Delete ${multiProject ? 'C-Config' : 'P-ProjConfig C-GlobalConfig'} ${projectName ? 'B-Back' : 'Q-Quit'}`))));
+    return (_jsxs(Box, { flexDirection: "column", children: [_jsxs(Box, { marginBottom: 1, flexDirection: "column", children: [_jsxs(Text, { bold: true, color: "green", children: ["CCManager - Claude Code Worktree Manager v", version] }), projectName && (_jsx(Text, { bold: true, color: "green", children: projectName }))] }), _jsx(Box, { marginBottom: 1, children: _jsx(Text, { dimColor: true, children: "Select a worktree to start or resume a Claude Code session:" }) }), isSearchMode && (_jsxs(Box, { marginBottom: 1, children: [_jsx(Text, { children: "Search: " }), _jsx(TextInputWrapper, { value: searchQuery, onChange: setSearchQuery, focus: true, placeholder: "Type to filter worktrees..." })] })), isSearchMode && items.length === 0 ? (_jsx(Box, { children: _jsx(Text, { color: "yellow", children: "No worktrees match your search" }) })) : isSearchMode ? (
+            // In search mode, show the items as a list without SelectInput
+            _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: !error, initialIndex: selectedIndex, limit: limit })), (error || loadError) && (_jsx(Box, { marginTop: 1, paddingX: 1, borderStyle: "round", borderColor: "red", children: _jsxs(Box, { flexDirection: "column", children: [_jsxs(Text, { color: "red", bold: true, children: ["Error: ", error || loadError] }), _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 N-New M-Merge D-Delete ${multiProject ? 'C-Config' : 'P-ProjConfig C-GlobalConfig'} ${projectName ? 'B-Back' : 'Q-Quit'}`
+                                : `Controls: ↑↓ Navigate Enter Select | Hotkeys: 0-9 Quick Select /-Search N-New M-Merge D-Delete ${multiProject ? 'C-Config' : 'P-ProjConfig C-GlobalConfig'} ${projectName ? 'B-Back' : 'Q-Quit'}` })] })] }));
 };
 export default Menu;

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

@@ -1,4 +1,4 @@
-import React from 'react';
+import { jsx as _jsx } from "react/jsx-runtime";
 import { describe, it, expect, vi, beforeEach, afterEach } from 'vitest';
 import { render } from 'ink-testing-library';
 import { Effect } from 'effect';
@@ -106,7 +106,7 @@ describe('Menu - Recent Projects', () => {
         vi.mocked(projectManager.getRecentProjects).mockReturnValue([
             { path: '/project1', name: 'Project 1', lastAccessed: 1000 },
         ]);
-        const { lastFrame } = render(React.createElement(Menu, { sessionManager: mockSessionManager, worktreeService: mockWorktreeService, onSelectWorktree: vi.fn(), multiProject: false }));
+        const { lastFrame } = render(_jsx(Menu, { sessionManager: mockSessionManager, worktreeService: mockWorktreeService, onSelectWorktree: vi.fn(), multiProject: false, version: "test" }));
         const output = lastFrame();
         expect(output).not.toContain('─ Recent ─');
         expect(output).not.toContain('Project 1');
@@ -126,7 +126,7 @@ describe('Menu - Recent Projects', () => {
             backgroundTasks: 0,
         });
         vi.spyOn(SessionManager, 'formatSessionCounts').mockReturnValue('');
-        const { lastFrame } = render(React.createElement(Menu, { sessionManager: mockSessionManager, worktreeService: mockWorktreeService, onSelectWorktree: vi.fn(), onSelectRecentProject: vi.fn(), multiProject: true }));
+        const { lastFrame } = render(_jsx(Menu, { sessionManager: mockSessionManager, worktreeService: mockWorktreeService, onSelectWorktree: vi.fn(), onSelectRecentProject: vi.fn(), multiProject: true, version: "test" }));
         // Wait for Effect to execute
         await new Promise(resolve => setTimeout(resolve, 100));
         const output = lastFrame();
@@ -136,7 +136,7 @@ describe('Menu - Recent Projects', () => {
     });
     it('should not show recent projects section when no recent projects', () => {
         vi.mocked(projectManager.getRecentProjects).mockReturnValue([]);
-        const { lastFrame } = render(React.createElement(Menu, { sessionManager: mockSessionManager, worktreeService: mockWorktreeService, onSelectWorktree: vi.fn(), onSelectRecentProject: vi.fn(), multiProject: true }));
+        const { lastFrame } = render(_jsx(Menu, { sessionManager: mockSessionManager, worktreeService: mockWorktreeService, onSelectWorktree: vi.fn(), onSelectRecentProject: vi.fn(), multiProject: true, version: "test" }));
         const output = lastFrame();
         expect(output).not.toContain('─ Recent ─');
     });
@@ -157,7 +157,7 @@ describe('Menu - Recent Projects', () => {
             backgroundTasks: 0,
         });
         vi.spyOn(SessionManager, 'formatSessionCounts').mockReturnValue('');
-        const { lastFrame } = render(React.createElement(Menu, { sessionManager: mockSessionManager, worktreeService: mockWorktreeService, onSelectWorktree: vi.fn(), onSelectRecentProject: vi.fn(), multiProject: true }));
+        const { lastFrame } = render(_jsx(Menu, { sessionManager: mockSessionManager, worktreeService: mockWorktreeService, onSelectWorktree: vi.fn(), onSelectRecentProject: vi.fn(), multiProject: true, version: "test" }));
         // Wait for Effect to execute
         await new Promise(resolve => setTimeout(resolve, 100));
         const output = lastFrame();
@@ -177,9 +177,9 @@ describe('Menu - Recent Projects', () => {
             ...mockWorktreeService,
             getGitRootPath: vi.fn().mockReturnValue('/current/project'),
         };
-        const { lastFrame, rerender } = render(React.createElement(Menu, { sessionManager: mockSessionManager, worktreeService: worktreeServiceWithGitRoot, onSelectWorktree: vi.fn(), onSelectRecentProject: vi.fn(), multiProject: true }));
+        const { lastFrame, rerender } = render(_jsx(Menu, { sessionManager: mockSessionManager, worktreeService: worktreeServiceWithGitRoot, onSelectWorktree: vi.fn(), onSelectRecentProject: vi.fn(), multiProject: true, version: "test" }));
         // Force a rerender to ensure all effects have run
-        rerender(React.createElement(Menu, { sessionManager: mockSessionManager, worktreeService: worktreeServiceWithGitRoot, onSelectWorktree: vi.fn(), onSelectRecentProject: vi.fn(), multiProject: true }));
+        rerender(_jsx(Menu, { sessionManager: mockSessionManager, worktreeService: worktreeServiceWithGitRoot, onSelectWorktree: vi.fn(), onSelectRecentProject: vi.fn(), multiProject: true, version: "test" }));
         // Wait for the state to update and component to re-render
         await new Promise(resolve => setTimeout(resolve, 50));
         const output = lastFrame();
@@ -198,7 +198,7 @@ describe('Menu - Recent Projects', () => {
         ]);
         // Mock getGitRootPath to return the current project path
         vi.mocked(mockWorktreeService.getGitRootPath).mockReturnValue('/current/project');
-        const { lastFrame } = render(React.createElement(Menu, { sessionManager: mockSessionManager, worktreeService: mockWorktreeService, onSelectWorktree: vi.fn(), onSelectRecentProject: vi.fn(), multiProject: true }));
+        const { lastFrame } = render(_jsx(Menu, { sessionManager: mockSessionManager, worktreeService: mockWorktreeService, onSelectWorktree: vi.fn(), onSelectRecentProject: vi.fn(), multiProject: true, version: "test" }));
         const output = lastFrame();
         expect(output).not.toContain('─ Recent ─');
         expect(output).not.toContain('Current Project');

package/dist/components/Menu.test.js

@@ -1,4 +1,4 @@
-import React from 'react';
+import { jsx as _jsx } from "react/jsx-runtime";
 import { render } from 'ink-testing-library';
 import Menu from './Menu.js';
 import { SessionManager } from '../services/sessionManager.js';
@@ -88,7 +88,7 @@ describe('Menu component Effect-based error handling', () => {
             stdout: '',
         });
         vi.spyOn(worktreeService, 'getWorktreesEffect').mockReturnValue(Effect.fail(gitError));
-        const { lastFrame } = render(React.createElement(Menu, { sessionManager: sessionManager, worktreeService: worktreeService, onSelectWorktree: onSelectWorktree, onDismissError: onDismissError }));
+        const { lastFrame } = render(_jsx(Menu, { sessionManager: sessionManager, worktreeService: worktreeService, onSelectWorktree: onSelectWorktree, onDismissError: onDismissError, version: "test" }));
         // Wait for Effect to execute
         await new Promise(resolve => setTimeout(resolve, 100));
         const output = lastFrame();
@@ -118,7 +118,7 @@ describe('Menu component Effect-based error handling', () => {
         vi.spyOn(worktreeService, 'getWorktreesEffect').mockReturnValue(Effect.succeed(mockWorktrees));
         // Mock getDefaultBranchEffect to return successful Effect
         vi.spyOn(worktreeService, 'getDefaultBranchEffect').mockReturnValue(Effect.succeed('main'));
-        const { lastFrame } = render(React.createElement(Menu, { sessionManager: sessionManager, worktreeService: worktreeService, onSelectWorktree: onSelectWorktree }));
+        const { lastFrame } = render(_jsx(Menu, { sessionManager: sessionManager, worktreeService: worktreeService, onSelectWorktree: onSelectWorktree, version: "test" }));
         // Wait for Effect to execute
         await new Promise(resolve => setTimeout(resolve, 100));
         const output = lastFrame();
@@ -149,7 +149,7 @@ describe('Menu component Effect-based error handling', () => {
             stdout: '',
         });
         vi.spyOn(worktreeService, 'getDefaultBranchEffect').mockReturnValue(Effect.fail(gitError));
-        const { lastFrame } = render(React.createElement(Menu, { sessionManager: sessionManager, worktreeService: worktreeService, onSelectWorktree: onSelectWorktree, onDismissError: onDismissError }));
+        const { lastFrame } = render(_jsx(Menu, { sessionManager: sessionManager, worktreeService: worktreeService, onSelectWorktree: onSelectWorktree, onDismissError: onDismissError, version: "test" }));
         // Wait for Effect to execute
         await new Promise(resolve => setTimeout(resolve, 100));
         const output = lastFrame();
@@ -176,7 +176,7 @@ describe('Menu component Effect-based error handling', () => {
         const getDefaultBranchSpy = vi
             .spyOn(worktreeService, 'getDefaultBranchEffect')
             .mockReturnValue(Effect.succeed('main'));
-        render(React.createElement(Menu, { sessionManager: sessionManager, worktreeService: worktreeService, onSelectWorktree: onSelectWorktree }));
+        render(_jsx(Menu, { sessionManager: sessionManager, worktreeService: worktreeService, onSelectWorktree: onSelectWorktree, version: "test" }));
         // Wait for Effect to execute
         await new Promise(resolve => setTimeout(resolve, 100));
         // Verify both Effect-based methods were called (Effect composition)
@@ -205,7 +205,7 @@ describe('Menu component rendering', () => {
     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 }));
+        const { unmount, lastFrame } = render(_jsx(Menu, { sessionManager: sessionManager, worktreeService: worktreeService, onSelectWorktree: onSelectWorktree, version: "test" }, 1));
         // Wait for async operations
         await new Promise(resolve => setTimeout(resolve, 100));
         const firstRenderOutput = lastFrame();
@@ -215,7 +215,7 @@ describe('Menu component rendering', () => {
         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 }));
+        const { lastFrame: lastFrame2 } = render(_jsx(Menu, { sessionManager: sessionManager, worktreeService: worktreeService, onSelectWorktree: onSelectWorktree, version: "test" }, 2));
         await new Promise(resolve => setTimeout(resolve, 100));
         const secondRenderOutput = lastFrame2();
         const titleCount2 = (secondRenderOutput?.match(/CCManager - Claude Code Worktree Manager/g) ||
@@ -224,7 +224,7 @@ describe('Menu component rendering', () => {
     });
     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 }));
+        const { lastFrame } = render(_jsx(Menu, { sessionManager: sessionManager, worktreeService: worktreeService, onSelectWorktree: onSelectWorktree, version: "test" }));
         await new Promise(resolve => setTimeout(resolve, 100));
         const output = lastFrame();
         // Check title appears only once
@@ -279,7 +279,7 @@ describe('Menu component rendering', () => {
             backgroundTasks: 0,
         });
         vi.spyOn(SessionManager, 'formatSessionCounts').mockReturnValue('');
-        const { lastFrame } = render(React.createElement(Menu, { sessionManager: sessionManager, worktreeService: worktreeService, onSelectWorktree: onSelectWorktree, onSelectRecentProject: onSelectRecentProject, multiProject: true }));
+        const { lastFrame } = render(_jsx(Menu, { sessionManager: sessionManager, worktreeService: worktreeService, onSelectWorktree: onSelectWorktree, onSelectRecentProject: onSelectRecentProject, multiProject: true, version: "test" }));
         await new Promise(resolve => setTimeout(resolve, 100));
         const output = lastFrame();
         // Check that worktrees have numbers 0-2
@@ -321,7 +321,7 @@ describe('Menu component rendering', () => {
             backgroundTasks: 0,
         });
         vi.spyOn(SessionManager, 'formatSessionCounts').mockReturnValue('');
-        const { lastFrame } = render(React.createElement(Menu, { sessionManager: sessionManager, worktreeService: worktreeService, onSelectWorktree: onSelectWorktree, onSelectRecentProject: onSelectRecentProject, multiProject: true }));
+        const { lastFrame } = render(_jsx(Menu, { sessionManager: sessionManager, worktreeService: worktreeService, onSelectWorktree: onSelectWorktree, onSelectRecentProject: onSelectRecentProject, multiProject: true, version: "test" }));
         await new Promise(resolve => setTimeout(resolve, 100));
         const output = lastFrame();
         // Check that recent projects don't have numbers (just ❯ prefix)