ccmanager 2.7.0 → 2.9.0

package/dist/components/Menu.js

@@ -1,6 +1,7 @@
 import React, { useState, useEffect } from 'react';
 import { Box, Text, useInput } from 'ink';
 import SelectInput from 'ink-select-input';
+import { Effect } from 'effect';
 import { SessionManager } from '../services/sessionManager.js';
 import { STATUS_ICONS, STATUS_LABELS, MENU_ICONS, } from '../constants/statusIcons.js';
 import { useGitStatus } from '../hooks/useGitStatus.js';
@@ -17,9 +18,17 @@ const createSeparatorWithText = (text, totalWidth = 35) => {
     const rightDashes = Math.ceil(remainingWidth / 2);
     return '─'.repeat(leftDashes) + textWithSpaces + '─'.repeat(rightDashes);
 };
+/**
+ * Format GitError for display
+ * Extracts relevant error information using pattern matching
+ */
+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 [baseWorktrees, setBaseWorktrees] = useState([]);
     const [defaultBranch, setDefaultBranch] = useState(null);
+    const [loadError, setLoadError] = useState(null);
     const worktrees = useGitStatus(baseWorktrees, defaultBranch);
     const [sessions, setSessions] = useState([]);
     const [items, setItems] = useState([]);
@@ -27,13 +36,53 @@ const Menu = ({ sessionManager, worktreeService, onSelectWorktree, onSelectRecen
     const limit = 10;
     // Use the search mode hook
     const { isSearchMode, searchQuery, selectedIndex, setSearchQuery } = useSearchMode(items.length, {
-        isDisabled: !!error,
+        isDisabled: !!error || !!loadError,
     });
     useEffect(() => {
-        // Load worktrees
-        const loadedWorktrees = worktreeService.getWorktrees();
-        setBaseWorktrees(loadedWorktrees);
-        setDefaultBranch(worktreeService.getDefaultBranch());
+        let cancelled = false;
+        // Load worktrees and default branch using Effect composition
+        // Chain getWorktreesEffect and getDefaultBranchEffect using Effect.flatMap
+        const loadWorktreesAndBranch = Effect.flatMap(worktreeService.getWorktreesEffect(), worktrees => Effect.map(worktreeService.getDefaultBranchEffect(), defaultBranch => ({
+            worktrees,
+            defaultBranch,
+        })));
+        Effect.runPromise(Effect.match(loadWorktreesAndBranch, {
+            onFailure: (error) => ({
+                success: false,
+                error,
+            }),
+            onSuccess: ({ worktrees, defaultBranch }) => ({
+                success: true,
+                worktrees,
+                defaultBranch,
+            }),
+        }))
+            .then(result => {
+            if (!cancelled) {
+                if (result.success) {
+                    setBaseWorktrees(result.worktrees);
+                    setDefaultBranch(result.defaultBranch);
+                    setLoadError(null);
+                    // Update sessions after worktrees are loaded
+                    const allSessions = sessionManager.getAllSessions();
+                    setSessions(allSessions);
+                    // Update worktree session status
+                    result.worktrees.forEach(wt => {
+                        wt.hasSession = allSessions.some(s => s.worktreePath === wt.path);
+                    });
+                }
+                else {
+                    // Handle GitError with pattern matching
+                    setLoadError(formatGitError(result.error));
+                }
+            }
+        })
+            .catch((err) => {
+            // This catch should not normally be reached with Effect.match
+            if (!cancelled) {
+                setLoadError(String(err));
+            }
+        });
         // Load recent projects if in multi-project mode
         if (multiProject) {
             // Filter out the current project from recent projects
@@ -42,22 +91,16 @@ const Menu = ({ sessionManager, worktreeService, onSelectWorktree, onSelectRecen
             const filteredProjects = allRecentProjects.filter((project) => project.path !== currentProjectPath);
             setRecentProjects(filteredProjects);
         }
-        // Update sessions
-        const updateSessions = () => {
+        // Listen for session changes
+        const handleSessionChange = () => {
             const allSessions = sessionManager.getAllSessions();
             setSessions(allSessions);
-            // Update worktree session status
-            loadedWorktrees.forEach(wt => {
-                wt.hasSession = allSessions.some(s => s.worktreePath === wt.path);
-            });
         };
-        updateSessions();
-        // Listen for session changes
-        const handleSessionChange = () => updateSessions();
         sessionManager.on('sessionCreated', handleSessionChange);
         sessionManager.on('sessionDestroyed', handleSessionChange);
         sessionManager.on('sessionStateChanged', handleSessionChange);
         return () => {
+            cancelled = true;
             sessionManager.off('sessionCreated', handleSessionChange);
             sessionManager.off('sessionDestroyed', handleSessionChange);
             sessionManager.off('sessionStateChanged', handleSessionChange);
@@ -200,6 +243,11 @@ const Menu = ({ sessionManager, worktreeService, onSelectWorktree, onSelectRecen
             onDismissError();
             return;
         }
+        // Dismiss load error on any key press when load error is shown
+        if (loadError) {
+            setLoadError(null);
+            return;
+        }
         // Don't process other keys if in search mode (handled by useSearchMode)
         if (isSearchMode) {
             return;
@@ -378,11 +426,11 @@ const Menu = ({ sessionManager, worktreeService, onSelectWorktree, onSelectRecen
         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 && (React.createElement(Box, { marginTop: 1, paddingX: 1, borderStyle: "round", borderColor: "red" },
+        (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),
+                    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 },

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

@@ -1,7 +1,9 @@
 import React from 'react';
 import { describe, it, expect, vi, beforeEach, afterEach } from 'vitest';
 import { render } from 'ink-testing-library';
+import { Effect } from 'effect';
 import Menu from './Menu.js';
+import { SessionManager } from '../services/sessionManager.js';
 import { projectManager } from '../services/projectManager.js';
 // Import the actual component code but skip the useInput hook
 vi.mock('ink', async () => {
@@ -30,6 +32,11 @@ vi.mock('../services/projectManager.js', () => ({
         getRecentProjects: vi.fn(),
     },
 }));
+vi.mock('../services/globalSessionOrchestrator.js', () => ({
+    globalSessionOrchestrator: {
+        getProjectSessions: vi.fn().mockReturnValue([]),
+    },
+}));
 vi.mock('../services/shortcutManager.js', () => ({
     shortcutManager: {
         getShortcutDisplay: vi.fn().mockReturnValue('Ctrl+C'),
@@ -57,15 +64,15 @@ describe('Menu - Recent Projects', () => {
             destroy: vi.fn(),
         };
         mockWorktreeService = {
-            getWorktrees: vi.fn().mockReturnValue([
+            getWorktreesEffect: vi.fn().mockReturnValue(Effect.succeed([
                 {
                     path: '/workspace/main',
                     branch: 'main',
                     isMainWorktree: true,
                     hasSession: false,
                 },
-            ]),
-            getDefaultBranch: vi.fn().mockReturnValue('main'),
+            ])),
+            getDefaultBranchEffect: vi.fn().mockReturnValue(Effect.succeed('main')),
             getGitRootPath: vi.fn().mockReturnValue('/default/project'),
         };
         vi.mocked(projectManager.getRecentProjects).mockReturnValue([]);
@@ -82,12 +89,22 @@ describe('Menu - Recent Projects', () => {
         expect(output).not.toContain('─ Recent ─');
         expect(output).not.toContain('Project 1');
     });
-    it('should show recent projects in multi-project mode', () => {
+    it('should show recent projects in multi-project mode', async () => {
         vi.mocked(projectManager.getRecentProjects).mockReturnValue([
             { path: '/project1', name: 'Project 1', lastAccessed: 2000 },
             { path: '/project2', name: 'Project 2', lastAccessed: 1000 },
         ]);
+        // Mock SessionManager static methods
+        vi.spyOn(SessionManager, 'getSessionCounts').mockReturnValue({
+            idle: 0,
+            busy: 0,
+            waiting_input: 0,
+            total: 0,
+        });
+        vi.spyOn(SessionManager, 'formatSessionCounts').mockReturnValue('');
         const { lastFrame } = render(React.createElement(Menu, { sessionManager: mockSessionManager, worktreeService: mockWorktreeService, onSelectWorktree: vi.fn(), onSelectRecentProject: vi.fn(), multiProject: true }));
+        // Wait for Effect to execute
+        await new Promise(resolve => setTimeout(resolve, 100));
         const output = lastFrame();
         expect(output).toContain('─ Recent ─');
         expect(output).toContain('Project 1');
@@ -99,25 +116,29 @@ describe('Menu - Recent Projects', () => {
         const output = lastFrame();
         expect(output).not.toContain('─ Recent ─');
     });
-    it('should show up to 5 recent projects', () => {
+    it('should show up to 5 recent projects', async () => {
         const manyProjects = Array.from({ length: 5 }, (_, i) => ({
             path: `/project${i}`,
             name: `Project ${i}`,
             lastAccessed: i * 1000,
         }));
         vi.mocked(projectManager.getRecentProjects).mockReturnValue(manyProjects);
+        // Mock SessionManager static methods
+        vi.spyOn(SessionManager, 'getSessionCounts').mockReturnValue({
+            idle: 0,
+            busy: 0,
+            waiting_input: 0,
+            total: 0,
+        });
+        vi.spyOn(SessionManager, 'formatSessionCounts').mockReturnValue('');
         const { lastFrame } = render(React.createElement(Menu, { sessionManager: mockSessionManager, worktreeService: mockWorktreeService, onSelectWorktree: vi.fn(), onSelectRecentProject: vi.fn(), multiProject: true }));
+        // Wait for Effect to execute
+        await new Promise(resolve => setTimeout(resolve, 100));
         const output = lastFrame();
         expect(output).toContain('─ Recent ─');
         expect(output).toContain('Project 0');
         expect(output).toContain('Project 4');
     });
-    it('should show recent projects between worktrees and New Worktree', () => {
-        // This test validates that recent projects appear in the correct order
-        // Since all other tests pass, we can consider this behavior verified
-        // by the other test cases that check for Recent Projects rendering
-        expect(true).toBe(true);
-    });
     it('should filter out current project from recent projects', async () => {
         // Setup the initial recent projects
         vi.mocked(projectManager.getRecentProjects).mockReturnValue([

package/dist/components/Menu.test.js

@@ -4,6 +4,10 @@ import Menu from './Menu.js';
 import { SessionManager } from '../services/sessionManager.js';
 import { WorktreeService } from '../services/worktreeService.js';
 import { vi, describe, it, expect, beforeEach, afterEach } from 'vitest';
+// Mock node-pty to avoid native module issues in tests
+vi.mock('node-pty', () => ({
+    spawn: vi.fn(),
+}));
 // Mock ink to avoid stdin issues
 vi.mock('ink', async () => {
     const actual = await vi.importActual('ink');
@@ -55,13 +59,139 @@ vi.mock('../hooks/useSearchMode.js', () => ({
         handleKey: vi.fn(),
     }),
 }));
-describe('Menu component rendering', () => {
+describe('Menu component Effect-based error handling', () => {
     let sessionManager;
     let worktreeService;
     beforeEach(() => {
         sessionManager = new SessionManager();
         worktreeService = new WorktreeService();
-        vi.spyOn(worktreeService, 'getWorktrees').mockReturnValue([]);
+        // Mock EventEmitter methods
+        vi.spyOn(sessionManager, 'on').mockImplementation(() => sessionManager);
+        vi.spyOn(sessionManager, 'off').mockImplementation(() => sessionManager);
+        vi.spyOn(sessionManager, 'getAllSessions').mockReturnValue([]);
+    });
+    afterEach(() => {
+        vi.restoreAllMocks();
+    });
+    it('should handle GitError from getWorktreesEffect and display error message', async () => {
+        const { Effect } = await import('effect');
+        const { GitError } = await import('../types/errors.js');
+        const onSelectWorktree = vi.fn();
+        const onDismissError = vi.fn();
+        // Mock getWorktreesEffect to return a failing Effect
+        const gitError = new GitError({
+            command: 'git worktree list --porcelain',
+            exitCode: 128,
+            stderr: 'fatal: not a git repository',
+            stdout: '',
+        });
+        vi.spyOn(worktreeService, 'getWorktreesEffect').mockReturnValue(Effect.fail(gitError));
+        const { lastFrame } = render(React.createElement(Menu, { sessionManager: sessionManager, worktreeService: worktreeService, onSelectWorktree: onSelectWorktree, onDismissError: onDismissError }));
+        // Wait for Effect to execute
+        await new Promise(resolve => setTimeout(resolve, 100));
+        const output = lastFrame();
+        // Should display error with GitError information
+        expect(output).toContain('Error:');
+        expect(output).toContain('git worktree list --porcelain');
+        expect(output).toContain('fatal: not a git repository');
+    });
+    it('should successfully load worktrees using getWorktreesEffect', async () => {
+        const { Effect } = await import('effect');
+        const onSelectWorktree = vi.fn();
+        const mockWorktrees = [
+            {
+                path: '/test/main',
+                branch: 'main',
+                isMainWorktree: true,
+                hasSession: false,
+            },
+            {
+                path: '/test/feature',
+                branch: 'feature-branch',
+                isMainWorktree: false,
+                hasSession: false,
+            },
+        ];
+        // Mock getWorktreesEffect to return successful Effect
+        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 }));
+        // Wait for Effect to execute
+        await new Promise(resolve => setTimeout(resolve, 100));
+        const output = lastFrame();
+        // Should display worktrees
+        expect(output).toContain('main');
+        expect(output).toContain('feature-branch');
+    });
+    it('should handle GitError from getDefaultBranchEffect and display error message', async () => {
+        const { Effect } = await import('effect');
+        const { GitError } = await import('../types/errors.js');
+        const onSelectWorktree = vi.fn();
+        const onDismissError = vi.fn();
+        const mockWorktrees = [
+            {
+                path: '/test/main',
+                branch: 'main',
+                isMainWorktree: true,
+                hasSession: false,
+            },
+        ];
+        // Mock getWorktreesEffect to succeed
+        vi.spyOn(worktreeService, 'getWorktreesEffect').mockReturnValue(Effect.succeed(mockWorktrees));
+        // Mock getDefaultBranchEffect to fail
+        const gitError = new GitError({
+            command: 'git symbolic-ref refs/remotes/origin/HEAD',
+            exitCode: 128,
+            stderr: 'fatal: ref refs/remotes/origin/HEAD is not a symbolic ref',
+            stdout: '',
+        });
+        vi.spyOn(worktreeService, 'getDefaultBranchEffect').mockReturnValue(Effect.fail(gitError));
+        const { lastFrame } = render(React.createElement(Menu, { sessionManager: sessionManager, worktreeService: worktreeService, onSelectWorktree: onSelectWorktree, onDismissError: onDismissError }));
+        // Wait for Effect to execute
+        await new Promise(resolve => setTimeout(resolve, 100));
+        const output = lastFrame();
+        // Should display error with GitError information
+        expect(output).toContain('Error:');
+        expect(output).toContain('git symbolic-ref');
+        expect(output).toContain('fatal: ref refs/remotes/origin/HEAD is not a symbolic ref');
+    });
+    it('should use Effect composition to load worktrees and default branch together', async () => {
+        const { Effect } = await import('effect');
+        const onSelectWorktree = vi.fn();
+        const mockWorktrees = [
+            {
+                path: '/test/main',
+                branch: 'main',
+                isMainWorktree: true,
+                hasSession: false,
+            },
+        ];
+        // Track that both Effects are called
+        const getWorktreesSpy = vi
+            .spyOn(worktreeService, 'getWorktreesEffect')
+            .mockReturnValue(Effect.succeed(mockWorktrees));
+        const getDefaultBranchSpy = vi
+            .spyOn(worktreeService, 'getDefaultBranchEffect')
+            .mockReturnValue(Effect.succeed('main'));
+        render(React.createElement(Menu, { sessionManager: sessionManager, worktreeService: worktreeService, onSelectWorktree: onSelectWorktree }));
+        // Wait for Effect to execute
+        await new Promise(resolve => setTimeout(resolve, 100));
+        // Verify both Effect-based methods were called (Effect composition)
+        expect(getWorktreesSpy).toHaveBeenCalled();
+        expect(getDefaultBranchSpy).toHaveBeenCalled();
+    });
+});
+describe('Menu component rendering', () => {
+    let sessionManager;
+    let worktreeService;
+    beforeEach(async () => {
+        const { Effect } = await import('effect');
+        sessionManager = new SessionManager();
+        worktreeService = new WorktreeService();
+        // Mock Effect-based methods
+        vi.spyOn(worktreeService, 'getWorktreesEffect').mockReturnValue(Effect.succeed([]));
+        vi.spyOn(worktreeService, 'getDefaultBranchEffect').mockReturnValue(Effect.succeed('main'));
         vi.spyOn(sessionManager, 'getAllSessions').mockReturnValue([]);
         // Mock EventEmitter methods
         vi.spyOn(sessionManager, 'on').mockImplementation(() => sessionManager);
@@ -103,6 +233,7 @@ describe('Menu component rendering', () => {
         expect(descMatches.length).toBe(1);
     });
     it('should display number shortcuts for recent projects when worktrees < 10', async () => {
+        const { Effect } = await import('effect');
         const onSelectWorktree = vi.fn();
         const onSelectRecentProject = vi.fn();
         // Setup: 3 worktrees
@@ -132,7 +263,7 @@ describe('Menu component rendering', () => {
             { name: 'Project B', path: '/test/project-b', lastAccessed: Date.now() },
             { name: 'Project C', path: '/test/project-c', lastAccessed: Date.now() },
         ];
-        vi.spyOn(worktreeService, 'getWorktrees').mockReturnValue(mockWorktrees);
+        vi.spyOn(worktreeService, 'getWorktreesEffect').mockReturnValue(Effect.succeed(mockWorktrees));
         vi.spyOn(worktreeService, 'getGitRootPath').mockReturnValue('/test/current');
         const { projectManager } = await import('../services/projectManager.js');
         vi.mocked(projectManager.getRecentProjects).mockReturnValue(mockRecentProjects);
@@ -157,6 +288,7 @@ describe('Menu component rendering', () => {
         expect(output).toContain('5 ❯ Project C');
     });
     it('should not display number shortcuts for recent projects when worktrees >= 10', async () => {
+        const { Effect } = await import('effect');
         const onSelectWorktree = vi.fn();
         const onSelectRecentProject = vi.fn();
         // Setup: 10 worktrees
@@ -171,7 +303,7 @@ describe('Menu component rendering', () => {
             { name: 'Project A', path: '/test/project-a', lastAccessed: Date.now() },
             { name: 'Project B', path: '/test/project-b', lastAccessed: Date.now() },
         ];
-        vi.spyOn(worktreeService, 'getWorktrees').mockReturnValue(mockWorktrees);
+        vi.spyOn(worktreeService, 'getWorktreesEffect').mockReturnValue(Effect.succeed(mockWorktrees));
         vi.spyOn(worktreeService, 'getGitRootPath').mockReturnValue('/test/current');
         const { projectManager } = await import('../services/projectManager.js');
         vi.mocked(projectManager.getRecentProjects).mockReturnValue(mockRecentProjects);

package/dist/components/MergeWorktree.js

@@ -1,9 +1,11 @@
 import React, { useState, useEffect } from 'react';
 import { Box, Text, useInput } from 'ink';
 import SelectInput from 'ink-select-input';
+import { Effect } from 'effect';
 import { WorktreeService } from '../services/worktreeService.js';
 import Confirmation, { SimpleConfirmation } from './Confirmation.js';
 import { shortcutManager } from '../services/shortcutManager.js';
+import { GitError } from '../types/errors.js';
 const MergeWorktree = ({ onComplete, onCancel, }) => {
     const [step, setStep] = useState('select-source');
     const [sourceBranch, setSourceBranch] = useState('');
@@ -13,16 +15,43 @@ const MergeWorktree = ({ onComplete, onCancel, }) => {
     const [useRebase, setUseRebase] = useState(false);
     const [mergeError, setMergeError] = useState(null);
     const [worktreeService] = useState(() => new WorktreeService());
+    const [isLoading, setIsLoading] = useState(true);
+    const [loadError, setLoadError] = useState(null);
     useEffect(() => {
-        const loadedWorktrees = worktreeService.getWorktrees();
-        // Create branch items for selection
-        const items = loadedWorktrees.map(wt => ({
-            label: (wt.branch ? wt.branch.replace('refs/heads/', '') : 'detached') +
-                (wt.isMainWorktree ? ' (main)' : ''),
-            value: wt.branch ? wt.branch.replace('refs/heads/', '') : 'detached',
-        }));
-        setBranchItems(items);
-        setOriginalBranchItems(items);
+        let cancelled = false;
+        const loadWorktrees = async () => {
+            try {
+                const loadedWorktrees = await Effect.runPromise(worktreeService.getWorktreesEffect());
+                if (!cancelled) {
+                    // Create branch items for selection
+                    const items = loadedWorktrees.map(wt => ({
+                        label: (wt.branch ? wt.branch.replace('refs/heads/', '') : 'detached') +
+                            (wt.isMainWorktree ? ' (main)' : ''),
+                        value: wt.branch
+                            ? wt.branch.replace('refs/heads/', '')
+                            : 'detached',
+                    }));
+                    setBranchItems(items);
+                    setOriginalBranchItems(items);
+                    setIsLoading(false);
+                }
+            }
+            catch (err) {
+                if (!cancelled) {
+                    const errorMessage = err instanceof GitError
+                        ? `Git error: ${err.stderr}`
+                        : err instanceof Error
+                            ? err.message
+                            : String(err);
+                    setLoadError(errorMessage);
+                    setIsLoading(false);
+                }
+            }
+        };
+        loadWorktrees();
+        return () => {
+            cancelled = true;
+        };
     }, [worktreeService]);
     useInput((input, key) => {
         if (shortcutManager.matchesShortcut('cancel', input, key)) {
@@ -51,19 +80,38 @@ const MergeWorktree = ({ onComplete, onCancel, }) => {
         if (step !== 'executing-merge')
             return;
         const performMerge = async () => {
-            const result = worktreeService.mergeWorktree(sourceBranch, targetBranch, useRebase);
-            if (result.success) {
+            try {
+                await Effect.runPromise(worktreeService.mergeWorktreeEffect(sourceBranch, targetBranch, useRebase));
                 // Merge successful, ask about deleting source branch
                 setStep('delete-confirm');
             }
-            else {
+            catch (err) {
                 // Merge failed, show error
-                setMergeError(result.error || 'Merge operation failed');
+                const errorMessage = err instanceof GitError
+                    ? `${err.command} failed: ${err.stderr}`
+                    : err instanceof Error
+                        ? err.message
+                        : 'Merge operation failed';
+                setMergeError(errorMessage);
                 setStep('merge-error');
             }
         };
         performMerge();
     }, [step, sourceBranch, targetBranch, useRebase, worktreeService]);
+    if (isLoading) {
+        return (React.createElement(Box, { flexDirection: "column" },
+            React.createElement(Text, { color: "cyan" }, "Loading worktrees...")));
+    }
+    if (loadError) {
+        return (React.createElement(Box, { flexDirection: "column" },
+            React.createElement(Text, { color: "red" }, "Error loading worktrees:"),
+            React.createElement(Text, { color: "red" }, loadError),
+            React.createElement(Box, { marginTop: 1 },
+                React.createElement(Text, { dimColor: true },
+                    "Press ",
+                    shortcutManager.getShortcutDisplay('cancel'),
+                    " to return to menu"))));
+    }
     if (step === 'select-source') {
         return (React.createElement(Box, { flexDirection: "column" },
             React.createElement(Box, { marginBottom: 1 },
@@ -160,13 +208,26 @@ const MergeWorktree = ({ onComplete, onCancel, }) => {
                 React.createElement(Text, { color: "yellow" }, sourceBranch),
                 ' ',
                 "and its worktree?")));
-        return (React.createElement(SimpleConfirmation, { message: deleteMessage, onConfirm: () => {
-                const deleteResult = worktreeService.deleteWorktreeByBranch(sourceBranch);
-                if (deleteResult.success) {
+        return (React.createElement(SimpleConfirmation, { message: deleteMessage, onConfirm: async () => {
+                try {
+                    // Find the worktree path for the source branch
+                    const worktrees = await Effect.runPromise(worktreeService.getWorktreesEffect());
+                    const sourceWorktree = worktrees.find(wt => wt.branch &&
+                        wt.branch.replace('refs/heads/', '') === sourceBranch);
+                    if (sourceWorktree) {
+                        await Effect.runPromise(worktreeService.deleteWorktreeEffect(sourceWorktree.path, {
+                            deleteBranch: true,
+                        }));
+                    }
                     onComplete();
                 }
-                else {
-                    setMergeError(deleteResult.error || 'Failed to delete worktree');
+                catch (err) {
+                    const errorMessage = err instanceof GitError
+                        ? `Delete failed: ${err.stderr}`
+                        : err instanceof Error
+                            ? err.message
+                            : 'Failed to delete worktree';
+                    setMergeError(errorMessage);
                     setStep('merge-error');
                 }
             }, onCancel: () => {

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

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