ccmanager 2.7.0 → 2.9.0

package/dist/services/worktreeService.test.js

@@ -1,9 +1,10 @@
-import { describe, it, expect, beforeEach, vi, afterEach } from 'vitest';
+import { describe, it, expect, beforeEach, vi } from 'vitest';
 import { WorktreeService } from './worktreeService.js';
 import { execSync } from 'child_process';
 import { existsSync, statSync } from 'fs';
 import { configurationManager } from './configurationManager.js';
-import { executeWorktreePostCreationHook } from '../utils/hookExecutor.js';
+import { Effect } from 'effect';
+import { GitError } from '../types/errors.js';
 // Mock child_process module
 vi.mock('child_process');
 // Mock fs module
@@ -31,7 +32,6 @@ const mockedExecSync = vi.mocked(execSync);
 const mockedExistsSync = vi.mocked(existsSync);
 const mockedStatSync = vi.mocked(statSync);
 const mockedGetWorktreeHooks = vi.mocked(configurationManager.getWorktreeHooks);
-const mockedExecuteHook = vi.mocked(executeWorktreePostCreationHook);
 describe('WorktreeService', () => {
     let service;
     beforeEach(() => {
@@ -119,8 +119,8 @@ describe('WorktreeService', () => {
             expect(result.startsWith('/')).toBe(true);
         });
     });
-    describe('getDefaultBranch', () => {
-        it('should return default branch from origin', () => {
+    describe('getDefaultBranchEffect', () => {
+        it('should return Effect with default branch from origin', async () => {
             mockedExecSync.mockImplementation((cmd, _options) => {
                 if (typeof cmd === 'string') {
                     if (cmd === 'git rev-parse --git-common-dir') {
@@ -132,7 +132,8 @@ describe('WorktreeService', () => {
                 }
                 throw new Error('Command not mocked: ' + cmd);
             });
-            const result = service.getDefaultBranch();
+            const effect = service.getDefaultBranchEffect();
+            const result = await Effect.runPromise(effect);
             expect(result).toBe('main');
             expect(execSync).toHaveBeenCalledWith("git symbolic-ref refs/remotes/origin/HEAD | sed 's@^refs/remotes/origin/@@'", expect.objectContaining({
                 cwd: '/fake/path',
@@ -140,7 +141,7 @@ describe('WorktreeService', () => {
                 shell: '/bin/bash',
             }));
         });
-        it('should fallback to main if origin HEAD fails', () => {
+        it('should fallback to main if origin HEAD fails', async () => {
             mockedExecSync.mockImplementation((cmd, _options) => {
                 if (typeof cmd === 'string') {
                     if (cmd === 'git rev-parse --git-common-dir') {
@@ -155,12 +156,13 @@ describe('WorktreeService', () => {
                 }
                 throw new Error('Not found');
             });
-            const result = service.getDefaultBranch();
+            const effect = service.getDefaultBranchEffect();
+            const result = await Effect.runPromise(effect);
             expect(result).toBe('main');
         });
     });
-    describe('getAllBranches', () => {
-        it('should return all branches without duplicates', () => {
+    describe('getAllBranchesEffect', () => {
+        it('should return Effect with all branches without duplicates', async () => {
             mockedExecSync.mockImplementation((cmd, _options) => {
                 if (typeof cmd === 'string') {
                     if (cmd === 'git rev-parse --git-common-dir') {
@@ -177,10 +179,11 @@ origin/feature/test
                 }
                 throw new Error('Command not mocked: ' + cmd);
             });
-            const result = service.getAllBranches();
+            const effect = service.getAllBranchesEffect();
+            const result = await Effect.runPromise(effect);
             expect(result).toEqual(['main', 'feature/test', 'feature/remote']);
         });
-        it('should return empty array on error', () => {
+        it('should return empty array on error', async () => {
             mockedExecSync.mockImplementation((cmd, _options) => {
                 if (typeof cmd === 'string' &&
                     cmd === 'git rev-parse --git-common-dir') {
@@ -188,10 +191,67 @@ origin/feature/test
                 }
                 throw new Error('Git error');
             });
-            const result = service.getAllBranches();
+            const effect = service.getAllBranchesEffect();
+            const result = await Effect.runPromise(effect);
             expect(result).toEqual([]);
         });
     });
+    describe('getCurrentBranchEffect', () => {
+        it('should return Effect with current branch name on success', async () => {
+            mockedExecSync.mockImplementation((cmd, _options) => {
+                if (typeof cmd === 'string') {
+                    if (cmd === 'git rev-parse --git-common-dir') {
+                        return '/fake/path/.git\n';
+                    }
+                    if (cmd === 'git rev-parse --abbrev-ref HEAD') {
+                        return 'feature-branch\n';
+                    }
+                }
+                throw new Error('Command not mocked: ' + cmd);
+            });
+            const effect = service.getCurrentBranchEffect();
+            const result = await Effect.runPromise(effect);
+            expect(result).toBe('feature-branch');
+            expect(execSync).toHaveBeenCalledWith('git rev-parse --abbrev-ref HEAD', expect.objectContaining({
+                cwd: '/fake/path',
+                encoding: 'utf8',
+            }));
+        });
+        it('should return Effect with "unknown" when git command fails', async () => {
+            mockedExecSync.mockImplementation((cmd, _options) => {
+                if (typeof cmd === 'string') {
+                    if (cmd === 'git rev-parse --git-common-dir') {
+                        return '/fake/path/.git\n';
+                    }
+                    if (cmd === 'git rev-parse --abbrev-ref HEAD') {
+                        throw new Error('fatal: not a git repository');
+                    }
+                }
+                throw new Error('Command not mocked: ' + cmd);
+            });
+            const effect = service.getCurrentBranchEffect();
+            const result = await Effect.runPromise(effect);
+            // Should fallback to 'unknown' instead of failing
+            expect(result).toBe('unknown');
+        });
+        it('should return Effect with "unknown" when branch name is empty', async () => {
+            mockedExecSync.mockImplementation((cmd, _options) => {
+                if (typeof cmd === 'string') {
+                    if (cmd === 'git rev-parse --git-common-dir') {
+                        return '/fake/path/.git\n';
+                    }
+                    if (cmd === 'git rev-parse --abbrev-ref HEAD') {
+                        return '\n'; // Empty branch name
+                    }
+                }
+                throw new Error('Command not mocked: ' + cmd);
+            });
+            const effect = service.getCurrentBranchEffect();
+            const result = await Effect.runPromise(effect);
+            // Should fallback to 'unknown' when no branch returned
+            expect(result).toBe('unknown');
+        });
+    });
     describe('resolveBranchReference', () => {
         it('should return local branch when it exists', () => {
             mockedExecSync.mockImplementation((cmd, _options) => {
@@ -308,88 +368,8 @@ origin/feature/test
             expect(result).toBe('foo/bar-xyz');
         });
     });
-    describe('createWorktree', () => {
-        it('should create worktree with base branch when branch does not exist', async () => {
-            mockedExecSync.mockImplementation((cmd, _options) => {
-                if (typeof cmd === 'string') {
-                    if (cmd === 'git rev-parse --git-common-dir') {
-                        return '/fake/path/.git\n';
-                    }
-                    if (cmd.includes('rev-parse --verify')) {
-                        throw new Error('Branch not found');
-                    }
-                    return '';
-                }
-                throw new Error('Unexpected command');
-            });
-            const result = await service.createWorktree('/path/to/worktree', 'new-feature', 'develop');
-            expect(result).toEqual({ success: true });
-            expect(execSync).toHaveBeenCalledWith('git worktree add -b "new-feature" "/path/to/worktree" "develop"', expect.any(Object));
-        });
-        it('should create worktree without base branch when branch exists', async () => {
-            mockedExecSync.mockImplementation((cmd, _options) => {
-                if (typeof cmd === 'string') {
-                    if (cmd === 'git rev-parse --git-common-dir') {
-                        return '/fake/path/.git\n';
-                    }
-                    if (cmd.includes('rev-parse --verify')) {
-                        return 'hash';
-                    }
-                    return '';
-                }
-                throw new Error('Unexpected command');
-            });
-            const result = await service.createWorktree('/path/to/worktree', 'existing-feature', 'main');
-            expect(result).toEqual({ success: true });
-            expect(execSync).toHaveBeenCalledWith('git worktree add "/path/to/worktree" "existing-feature"', expect.any(Object));
-        });
-        it('should handle ambiguous branch error gracefully', async () => {
-            mockedExecSync.mockImplementation((cmd, _options) => {
-                if (typeof cmd === 'string') {
-                    if (cmd === 'git rev-parse --git-common-dir') {
-                        return '/fake/path/.git\n';
-                    }
-                    if (cmd.includes('rev-parse --verify new-feature')) {
-                        throw new Error('Branch not found');
-                    }
-                    if (cmd.includes('show-ref --verify --quiet refs/heads/foo/bar-xyz')) {
-                        throw new Error('Local branch not found');
-                    }
-                    if (cmd === 'git remote') {
-                        return 'origin\nupstream\n';
-                    }
-                    if (cmd.includes('show-ref --verify --quiet refs/remotes/origin/foo/bar-xyz') ||
-                        cmd.includes('show-ref --verify --quiet refs/remotes/upstream/foo/bar-xyz')) {
-                        return ''; // Both remotes have the branch
-                    }
-                }
-                throw new Error('Command not mocked: ' + cmd);
-            });
-            const result = await service.createWorktree('/path/to/worktree', 'new-feature', 'foo/bar-xyz');
-            expect(result.success).toBe(false);
-            expect(result.error).toContain("Ambiguous branch 'foo/bar-xyz' found in multiple remotes");
-            expect(result.error).toContain('origin/foo/bar-xyz, upstream/foo/bar-xyz');
-        });
-        it('should create worktree from specified base branch when branch does not exist', async () => {
-            mockedExecSync.mockImplementation((cmd, _options) => {
-                if (typeof cmd === 'string') {
-                    if (cmd === 'git rev-parse --git-common-dir') {
-                        return '/fake/path/.git\n';
-                    }
-                    if (cmd.includes('rev-parse --verify')) {
-                        throw new Error('Branch not found');
-                    }
-                    return '';
-                }
-                throw new Error('Unexpected command');
-            });
-            const result = await service.createWorktree('/path/to/worktree', 'new-feature', 'main');
-            expect(result).toEqual({ success: true });
-            expect(execSync).toHaveBeenCalledWith('git worktree add -b "new-feature" "/path/to/worktree" "main"', expect.any(Object));
-        });
-    });
-    describe('hasClaudeDirectoryInBranch', () => {
-        it('should return true when .claude directory exists in branch worktree', () => {
+    describe('hasClaudeDirectoryInBranchEffect', () => {
+        it('should return Effect with true when .claude directory exists in branch worktree', async () => {
             mockedExecSync.mockImplementation((cmd, _options) => {
                 if (typeof cmd === 'string') {
                     if (cmd === 'git rev-parse --git-common-dir') {
@@ -414,12 +394,13 @@ branch refs/heads/feature-branch
             mockedStatSync.mockImplementation(() => ({
                 isDirectory: () => true,
             }));
-            const result = service.hasClaudeDirectoryInBranch('feature-branch');
+            const effect = service.hasClaudeDirectoryInBranchEffect('feature-branch');
+            const result = await Effect.runPromise(effect);
             expect(result).toBe(true);
             expect(existsSync).toHaveBeenCalledWith('/fake/path/feature-branch/.claude');
             expect(statSync).toHaveBeenCalledWith('/fake/path/feature-branch/.claude');
         });
-        it('should return false when .claude directory does not exist', () => {
+        it('should return Effect with false when .claude directory does not exist', async () => {
             mockedExecSync.mockImplementation((cmd, _options) => {
                 if (typeof cmd === 'string') {
                     if (cmd === 'git rev-parse --git-common-dir') {
@@ -439,11 +420,12 @@ branch refs/heads/feature-branch
                 throw new Error('Command not mocked: ' + cmd);
             });
             mockedExistsSync.mockReturnValue(false);
-            const result = service.hasClaudeDirectoryInBranch('feature-branch');
+            const effect = service.hasClaudeDirectoryInBranchEffect('feature-branch');
+            const result = await Effect.runPromise(effect);
             expect(result).toBe(false);
             expect(existsSync).toHaveBeenCalledWith('/fake/path/feature-branch/.claude');
         });
-        it('should return false when .claude exists but is not a directory', () => {
+        it('should return Effect with false when .claude exists but is not a directory', async () => {
             mockedExecSync.mockImplementation((cmd, _options) => {
                 if (typeof cmd === 'string') {
                     if (cmd === 'git rev-parse --git-common-dir') {
@@ -466,10 +448,11 @@ branch refs/heads/feature-branch
             mockedStatSync.mockImplementation(() => ({
                 isDirectory: () => false,
             }));
-            const result = service.hasClaudeDirectoryInBranch('feature-branch');
+            const effect = service.hasClaudeDirectoryInBranchEffect('feature-branch');
+            const result = await Effect.runPromise(effect);
             expect(result).toBe(false);
         });
-        it('should fallback to default branch when branch worktree not found', () => {
+        it('should fallback to default branch when branch worktree not found', async () => {
             mockedExecSync.mockImplementation((cmd, _options) => {
                 if (typeof cmd === 'string') {
                     if (cmd === 'git rev-parse --git-common-dir') {
@@ -492,11 +475,12 @@ branch refs/heads/main
                 isDirectory: () => true,
             }));
             // When asking for main branch that doesn't have a separate worktree
-            const result = service.hasClaudeDirectoryInBranch('main');
+            const effect = service.hasClaudeDirectoryInBranchEffect('main');
+            const result = await Effect.runPromise(effect);
             expect(result).toBe(true);
             expect(existsSync).toHaveBeenCalledWith('/fake/path/.claude');
         });
-        it('should return false when branch not found in any worktree', () => {
+        it('should return Effect with false when branch not found in any worktree', async () => {
             mockedExecSync.mockImplementation((cmd, _options) => {
                 if (typeof cmd === 'string') {
                     if (cmd === 'git rev-parse --git-common-dir') {
@@ -514,10 +498,11 @@ branch refs/heads/main
                 }
                 throw new Error('Command not mocked: ' + cmd);
             });
-            const result = service.hasClaudeDirectoryInBranch('non-existent-branch');
+            const effect = service.hasClaudeDirectoryInBranchEffect('non-existent-branch');
+            const result = await Effect.runPromise(effect);
             expect(result).toBe(false);
         });
-        it('should check main worktree when branch is default branch', () => {
+        it('should check main worktree when branch is default branch', async () => {
             mockedExecSync.mockImplementation((cmd, _options) => {
                 if (typeof cmd === 'string') {
                     if (cmd === 'git rev-parse --git-common-dir') {
@@ -543,327 +528,323 @@ branch refs/heads/other-branch
             mockedStatSync.mockImplementation(() => ({
                 isDirectory: () => true,
             }));
-            const result = service.hasClaudeDirectoryInBranch('main');
+            const effect = service.hasClaudeDirectoryInBranchEffect('main');
+            const result = await Effect.runPromise(effect);
             expect(result).toBe(true);
             expect(existsSync).toHaveBeenCalledWith('/fake/path/.claude');
         });
     });
-    describe('Worktree Hook Execution', () => {
-        afterEach(() => {
-            vi.clearAllMocks();
-        });
-        it('should execute post-creation hook when worktree is created', async () => {
-            // Arrange
-            const hookCommand = 'echo "Worktree created: $CCMANAGER_WORKTREE_PATH"';
-            mockedGetWorktreeHooks.mockReturnValue({
-                post_creation: {
-                    command: hookCommand,
-                    enabled: true,
-                },
-            });
-            mockedExecuteHook.mockResolvedValue(undefined);
+    describe('Effect-based getWorktrees', () => {
+        it('should return Effect with worktree array on success', async () => {
             mockedExecSync.mockImplementation((cmd, _options) => {
                 if (typeof cmd === 'string') {
                     if (cmd === 'git rev-parse --git-common-dir') {
                         return '/fake/path/.git\n';
                     }
-                    if (cmd.includes('git worktree list')) {
-                        return 'worktree /fake/path\nHEAD abc123\nbranch refs/heads/main\n';
-                    }
-                    if (cmd.includes('git worktree add')) {
-                        return '';
-                    }
-                    if (cmd.includes('git rev-parse --verify')) {
-                        throw new Error('Branch not found');
+                    if (cmd === 'git worktree list --porcelain') {
+                        return `worktree /fake/path
+HEAD abcd1234
+branch refs/heads/main
+
+worktree /fake/path/feature
+HEAD efgh5678
+branch refs/heads/feature
+`;
                     }
                 }
-                return '';
+                throw new Error('Command not mocked: ' + cmd);
             });
-            // Act
-            const result = await service.createWorktree('feature-branch-dir', 'feature-branch', 'main', false, false);
-            // Assert
-            expect(result.success).toBe(true);
-            expect(mockedGetWorktreeHooks).toHaveBeenCalled();
-            expect(mockedExecuteHook).toHaveBeenCalledWith(hookCommand, expect.objectContaining({
-                path: '/fake/path/feature-branch-dir',
-                branch: 'feature-branch',
+            const effect = service.getWorktreesEffect();
+            const result = await Effect.runPromise(effect);
+            expect(result).toHaveLength(2);
+            expect(result[0]).toMatchObject({
+                path: '/fake/path',
+                branch: 'main',
+                isMainWorktree: true,
+            });
+            expect(result[1]).toMatchObject({
+                path: '/fake/path/feature',
+                branch: 'feature',
                 isMainWorktree: false,
-                hasSession: false,
-            }), '/fake/path', 'main');
-        });
-        it('should not execute hook when disabled', async () => {
-            // Arrange
-            mockedGetWorktreeHooks.mockReturnValue({
-                post_creation: {
-                    command: 'echo "Should not run"',
-                    enabled: false,
-                },
             });
+        });
+        it('should return Effect that fails with GitError when git command fails', async () => {
             mockedExecSync.mockImplementation((cmd, _options) => {
                 if (typeof cmd === 'string') {
                     if (cmd === 'git rev-parse --git-common-dir') {
                         return '/fake/path/.git\n';
                     }
-                    if (cmd.includes('git worktree list')) {
-                        return 'worktree /fake/path\nHEAD abc123\nbranch refs/heads/main\n';
-                    }
-                    if (cmd.includes('git worktree add')) {
-                        return '';
-                    }
-                    if (cmd.includes('git rev-parse --verify')) {
-                        throw new Error('Branch not found');
+                    if (cmd === 'git worktree list --porcelain') {
+                        const error = new Error('fatal: not a git repository');
+                        error.status = 128;
+                        error.stderr = 'fatal: not a git repository';
+                        throw error;
                     }
                 }
-                return '';
+                throw new Error('Command not mocked: ' + cmd);
             });
-            // Act
-            const result = await service.createWorktree('feature-branch-dir', 'feature-branch', 'main', false, false);
-            // Assert
-            expect(result.success).toBe(true);
-            expect(mockedGetWorktreeHooks).toHaveBeenCalled();
-            expect(mockedExecuteHook).not.toHaveBeenCalled();
+            const effect = service.getWorktreesEffect();
+            const result = await Effect.runPromise(Effect.either(effect));
+            if (result._tag === 'Left') {
+                expect(result.left).toBeInstanceOf(GitError);
+                expect(result.left.command).toBe('git worktree list --porcelain');
+                expect(result.left.exitCode).toBe(128);
+                expect(result.left.stderr).toContain('not a git repository');
+            }
+            else {
+                expect.fail('Should have returned Left with GitError');
+            }
         });
-        it('should not execute hook when not configured', async () => {
-            // Arrange
-            mockedGetWorktreeHooks.mockReturnValue({});
+        it('should fallback to single worktree when git worktree command not supported', async () => {
             mockedExecSync.mockImplementation((cmd, _options) => {
                 if (typeof cmd === 'string') {
                     if (cmd === 'git rev-parse --git-common-dir') {
                         return '/fake/path/.git\n';
                     }
-                    if (cmd.includes('git worktree list')) {
-                        return 'worktree /fake/path\nHEAD abc123\nbranch refs/heads/main\n';
-                    }
-                    if (cmd.includes('git worktree add')) {
-                        return '';
+                    if (cmd === 'git worktree list --porcelain') {
+                        const error = new Error('unknown command: worktree');
+                        error.status = 1;
+                        error.stderr = 'unknown command: worktree';
+                        throw error;
                     }
-                    if (cmd.includes('git rev-parse --verify')) {
-                        throw new Error('Branch not found');
+                    if (cmd === 'git rev-parse --abbrev-ref HEAD') {
+                        return 'main\n';
                     }
                 }
-                return '';
+                throw new Error('Command not mocked: ' + cmd);
+            });
+            const effect = service.getWorktreesEffect();
+            const result = await Effect.runPromise(effect);
+            expect(result).toHaveLength(1);
+            expect(result[0]).toMatchObject({
+                path: '/fake/path',
+                branch: 'main',
+                isMainWorktree: true,
             });
-            // Act
-            const result = await service.createWorktree('feature-branch-dir', 'feature-branch', 'main', false, false);
-            // Assert
-            expect(result.success).toBe(true);
-            expect(mockedGetWorktreeHooks).toHaveBeenCalled();
-            expect(mockedExecuteHook).not.toHaveBeenCalled();
-        });
-        it('should not fail worktree creation if hook execution fails', async () => {
-            // Arrange
-            mockedGetWorktreeHooks.mockReturnValue({
-                post_creation: {
-                    command: 'failing-command',
-                    enabled: true,
-                },
-            });
-            // The real executeWorktreePostCreationHook doesn't throw, it catches errors internally
-            // So the mock should resolve, not reject
-            mockedExecuteHook.mockResolvedValue(undefined);
+        });
+    });
+    describe('Effect-based createWorktree', () => {
+        it('should return Effect with Worktree on success', async () => {
             mockedExecSync.mockImplementation((cmd, _options) => {
                 if (typeof cmd === 'string') {
                     if (cmd === 'git rev-parse --git-common-dir') {
                         return '/fake/path/.git\n';
                     }
-                    if (cmd.includes('git worktree list')) {
-                        return 'worktree /fake/path\nHEAD abc123\nbranch refs/heads/main\n';
+                    if (cmd.includes('rev-parse --verify')) {
+                        throw new Error('Branch not found');
                     }
                     if (cmd.includes('git worktree add')) {
                         return '';
                     }
-                    if (cmd.includes('git rev-parse --verify')) {
-                        throw new Error('Branch not found');
-                    }
                 }
                 return '';
             });
-            // Act
-            const result = await service.createWorktree('feature-branch-dir', 'feature-branch', 'main', false, false);
-            // Allow async operations to complete
-            await new Promise(resolve => setTimeout(resolve, 10));
-            // Assert
-            expect(result.success).toBe(true);
-            expect(mockedExecuteHook).toHaveBeenCalled();
+            const effect = service.createWorktreeEffect('/path/to/worktree', 'new-feature', 'main');
+            const result = await Effect.runPromise(effect);
+            expect(result).toMatchObject({
+                path: '/path/to/worktree',
+                branch: 'new-feature',
+                isMainWorktree: false,
+            });
         });
-    });
-    describe('AmbiguousBranchError Integration', () => {
-        it('should return error message when createWorktree encounters ambiguous branch', async () => {
+        it('should return Effect that fails with GitError on git command failure', async () => {
             mockedExecSync.mockImplementation((cmd, _options) => {
                 if (typeof cmd === 'string') {
                     if (cmd === 'git rev-parse --git-common-dir') {
                         return '/fake/path/.git\n';
                     }
-                    if (cmd.includes('rev-parse --verify new-feature')) {
+                    if (cmd.includes('rev-parse --verify')) {
                         throw new Error('Branch not found');
                     }
-                    if (cmd.includes('show-ref --verify --quiet refs/heads/ambiguous-branch')) {
-                        throw new Error('Local branch not found');
-                    }
-                    if (cmd === 'git remote') {
-                        return 'origin\nupstream\n';
-                    }
-                    if (cmd.includes('show-ref --verify --quiet refs/remotes/origin/ambiguous-branch') ||
-                        cmd.includes('show-ref --verify --quiet refs/remotes/upstream/ambiguous-branch')) {
-                        return ''; // Both remotes have the branch
+                    if (cmd.includes('git worktree add')) {
+                        const error = new Error('fatal: invalid reference: main');
+                        error.status = 128;
+                        error.stderr = 'fatal: invalid reference: main';
+                        throw error;
                     }
                 }
                 throw new Error('Command not mocked: ' + cmd);
             });
-            const result = await service.createWorktree('/path/to/worktree', 'new-feature', 'ambiguous-branch');
-            expect(result.success).toBe(false);
-            expect(result.error).toContain("Ambiguous branch 'ambiguous-branch' found in multiple remotes");
-            expect(result.error).toContain('origin/ambiguous-branch, upstream/ambiguous-branch');
-            expect(result.error).toContain('Please specify which remote to use');
+            const effect = service.createWorktreeEffect('/path/to/worktree', 'new-feature', 'main');
+            const result = await Effect.runPromise(Effect.either(effect));
+            if (result._tag === 'Left') {
+                expect(result.left).toBeInstanceOf(GitError);
+                expect(result.left.exitCode).toBe(128);
+                expect(result.left.stderr).toContain('invalid reference');
+            }
+            else {
+                expect.fail('Should have returned Left with GitError');
+            }
         });
-        it('should successfully create worktree with resolved remote reference', async () => {
+    });
+    describe('Effect-based deleteWorktree', () => {
+        it('should return Effect with void on success', async () => {
             mockedExecSync.mockImplementation((cmd, _options) => {
                 if (typeof cmd === 'string') {
                     if (cmd === 'git rev-parse --git-common-dir') {
                         return '/fake/path/.git\n';
                     }
-                    if (cmd.includes('rev-parse --verify new-feature')) {
-                        throw new Error('Branch not found');
-                    }
-                    // Simulate resolved reference (origin/ambiguous-branch) exists
-                    if (cmd.includes('show-ref --verify --quiet refs/heads/origin/ambiguous-branch')) {
-                        throw new Error('Local branch not found');
-                    }
-                    if (cmd === 'git remote') {
-                        return 'origin\n';
+                    if (cmd === 'git worktree list --porcelain') {
+                        return `worktree /fake/path
+HEAD abcd1234
+branch refs/heads/main
+
+worktree /fake/path/feature
+HEAD efgh5678
+branch refs/heads/feature
+`;
                     }
-                    if (cmd.includes('show-ref --verify --quiet refs/remotes/origin/origin/ambiguous-branch')) {
-                        throw new Error('Remote branch not found'); // This is expected for resolved reference
+                    if (cmd.includes('git worktree remove')) {
+                        return '';
                     }
-                    // Mock successful worktree creation with resolved reference
-                    if (cmd.includes('git worktree add -b "new-feature" "/path/to/worktree" "origin/ambiguous-branch"')) {
+                    if (cmd.includes('git branch -D')) {
                         return '';
                     }
                 }
                 throw new Error('Command not mocked: ' + cmd);
             });
-            mockedExistsSync.mockReturnValue(false);
-            const result = await service.createWorktree('/path/to/worktree', 'new-feature', 'origin/ambiguous-branch');
-            expect(result.success).toBe(true);
-            expect(mockedExecSync).toHaveBeenCalledWith('git worktree add -b "new-feature" "/path/to/worktree" "origin/ambiguous-branch"', { cwd: '/fake/path', encoding: 'utf8' });
+            const effect = service.deleteWorktreeEffect('/fake/path/feature');
+            await Effect.runPromise(effect);
+            expect(execSync).toHaveBeenCalledWith(expect.stringContaining('git worktree remove'), expect.any(Object));
         });
-        it('should handle three-way ambiguous branch scenario', async () => {
+        it('should return Effect that fails with GitError when worktree not found', async () => {
             mockedExecSync.mockImplementation((cmd, _options) => {
                 if (typeof cmd === 'string') {
                     if (cmd === 'git rev-parse --git-common-dir') {
                         return '/fake/path/.git\n';
                     }
-                    if (cmd.includes('rev-parse --verify test-branch')) {
-                        throw new Error('Branch not found');
-                    }
-                    if (cmd.includes('show-ref --verify --quiet refs/heads/three-way-branch')) {
-                        throw new Error('Local branch not found');
-                    }
-                    if (cmd === 'git remote') {
-                        return 'origin\nupstream\nfork\n';
-                    }
-                    // All three remotes have the branch
-                    if (cmd.includes('show-ref --verify --quiet refs/remotes/origin/three-way-branch') ||
-                        cmd.includes('show-ref --verify --quiet refs/remotes/upstream/three-way-branch') ||
-                        cmd.includes('show-ref --verify --quiet refs/remotes/fork/three-way-branch')) {
-                        return '';
+                    if (cmd === 'git worktree list --porcelain') {
+                        return `worktree /fake/path
+HEAD abcd1234
+branch refs/heads/main
+`;
                     }
                 }
                 throw new Error('Command not mocked: ' + cmd);
             });
-            const result = await service.createWorktree('/path/to/worktree', 'test-branch', 'three-way-branch');
-            expect(result.success).toBe(false);
-            expect(result.error).toContain("Ambiguous branch 'three-way-branch' found in multiple remotes");
-            expect(result.error).toContain('origin/three-way-branch, upstream/three-way-branch, fork/three-way-branch');
+            const effect = service.deleteWorktreeEffect('/fake/path/nonexistent');
+            const result = await Effect.runPromise(Effect.either(effect));
+            if (result._tag === 'Left') {
+                expect(result.left).toBeInstanceOf(GitError);
+                expect(result.left.stderr).toContain('Worktree not found');
+            }
+            else {
+                expect.fail('Should have returned Left with GitError');
+            }
         });
-        it('should handle complex branch names with slashes in ambiguous scenario', async () => {
+        it('should return Effect that fails with GitError when trying to delete main worktree', async () => {
             mockedExecSync.mockImplementation((cmd, _options) => {
                 if (typeof cmd === 'string') {
                     if (cmd === 'git rev-parse --git-common-dir') {
                         return '/fake/path/.git\n';
                     }
-                    if (cmd.includes('rev-parse --verify new-feature')) {
-                        throw new Error('Branch not found');
-                    }
-                    if (cmd.includes('show-ref --verify --quiet refs/heads/feature/sub/complex-name')) {
-                        throw new Error('Local branch not found');
-                    }
-                    if (cmd === 'git remote') {
-                        return 'origin\nfork\n';
-                    }
-                    if (cmd.includes('show-ref --verify --quiet refs/remotes/origin/feature/sub/complex-name') ||
-                        cmd.includes('show-ref --verify --quiet refs/remotes/fork/feature/sub/complex-name')) {
-                        return '';
+                    if (cmd === 'git worktree list --porcelain') {
+                        return `worktree /fake/path
+HEAD abcd1234
+branch refs/heads/main
+`;
                     }
                 }
                 throw new Error('Command not mocked: ' + cmd);
             });
-            const result = await service.createWorktree('/path/to/worktree', 'new-feature', 'feature/sub/complex-name');
-            expect(result.success).toBe(false);
-            expect(result.error).toContain("Ambiguous branch 'feature/sub/complex-name' found in multiple remotes");
-            expect(result.error).toContain('origin/feature/sub/complex-name, fork/feature/sub/complex-name');
+            const effect = service.deleteWorktreeEffect('/fake/path');
+            const result = await Effect.runPromise(Effect.either(effect));
+            if (result._tag === 'Left') {
+                expect(result.left).toBeInstanceOf(GitError);
+                expect(result.left.stderr).toContain('Cannot delete the main worktree');
+            }
+            else {
+                expect.fail('Should have returned Left with GitError');
+            }
         });
-        it('should successfully resolve single remote branch with slashes', async () => {
+    });
+    describe('Effect-based mergeWorktree', () => {
+        it('should return Effect with void on successful merge', async () => {
             mockedExecSync.mockImplementation((cmd, _options) => {
                 if (typeof cmd === 'string') {
                     if (cmd === 'git rev-parse --git-common-dir') {
                         return '/fake/path/.git\n';
                     }
-                    if (cmd.includes('rev-parse --verify new-feature')) {
-                        throw new Error('Branch not found');
-                    }
-                    if (cmd.includes('show-ref --verify --quiet refs/heads/feature/auto-resolve')) {
-                        throw new Error('Local branch not found');
-                    }
-                    if (cmd === 'git remote') {
-                        return 'origin\nupstream\n';
+                    if (cmd === 'git worktree list --porcelain') {
+                        return `worktree /fake/path
+HEAD abcd1234
+branch refs/heads/main
+
+worktree /fake/path/feature
+HEAD efgh5678
+branch refs/heads/feature
+`;
                     }
-                    // Only origin has this branch
-                    if (cmd.includes('show-ref --verify --quiet refs/remotes/origin/feature/auto-resolve')) {
-                        return '';
+                    if (cmd.includes('git merge')) {
+                        return 'Merge successful';
                     }
-                    if (cmd.includes('show-ref --verify --quiet refs/remotes/upstream/feature/auto-resolve')) {
-                        throw new Error('Remote branch not found');
+                }
+                throw new Error('Command not mocked: ' + cmd);
+            });
+            const effect = service.mergeWorktreeEffect('feature', 'main', false);
+            await Effect.runPromise(effect);
+            expect(execSync).toHaveBeenCalledWith('git merge --no-ff "feature"', expect.any(Object));
+        });
+        it('should return Effect that fails with GitError when target branch not found', async () => {
+            mockedExecSync.mockImplementation((cmd, _options) => {
+                if (typeof cmd === 'string') {
+                    if (cmd === 'git rev-parse --git-common-dir') {
+                        return '/fake/path/.git\n';
                     }
-                    // Mock successful worktree creation with auto-resolved reference
-                    if (cmd.includes('git worktree add -b "new-feature" "/path/to/worktree" "origin/feature/auto-resolve"')) {
-                        return '';
+                    if (cmd === 'git worktree list --porcelain') {
+                        return `worktree /fake/path
+HEAD abcd1234
+branch refs/heads/main
+`;
                     }
                 }
                 throw new Error('Command not mocked: ' + cmd);
             });
-            mockedExistsSync.mockReturnValue(false);
-            const result = await service.createWorktree('/path/to/worktree', 'new-feature', 'feature/auto-resolve');
-            expect(result.success).toBe(true);
-            expect(mockedExecSync).toHaveBeenCalledWith('git worktree add -b "new-feature" "/path/to/worktree" "origin/feature/auto-resolve"', { cwd: '/fake/path', encoding: 'utf8' });
+            const effect = service.mergeWorktreeEffect('feature', 'nonexistent', false);
+            const result = await Effect.runPromise(Effect.either(effect));
+            if (result._tag === 'Left') {
+                expect(result.left).toBeInstanceOf(GitError);
+                expect(result.left.stderr).toContain('Target branch worktree not found');
+            }
+            else {
+                expect.fail('Should have returned Left with GitError');
+            }
         });
-        it('should prioritize local branch over remote branches', async () => {
+        it('should return Effect that fails with GitError on merge conflict', async () => {
             mockedExecSync.mockImplementation((cmd, _options) => {
                 if (typeof cmd === 'string') {
                     if (cmd === 'git rev-parse --git-common-dir') {
                         return '/fake/path/.git\n';
                     }
-                    if (cmd.includes('rev-parse --verify new-feature')) {
-                        throw new Error('Branch not found');
-                    }
-                    // Local branch exists (highest priority)
-                    if (cmd.includes('show-ref --verify --quiet refs/heads/local-priority')) {
-                        return '';
+                    if (cmd === 'git worktree list --porcelain') {
+                        return `worktree /fake/path
+HEAD abcd1234
+branch refs/heads/main
+
+worktree /fake/path/feature
+HEAD efgh5678
+branch refs/heads/feature
+`;
                     }
-                    // Remote checks should not be executed when local exists
-                    // Mock successful worktree creation with local branch
-                    if (cmd.includes('git worktree add -b "new-feature" "/path/to/worktree" "local-priority"')) {
-                        return '';
+                    if (cmd.includes('git merge')) {
+                        const error = new Error('CONFLICT: Merge conflict');
+                        error.status = 1;
+                        error.stderr = 'CONFLICT: Merge conflict in file.txt';
+                        throw error;
                     }
                 }
                 throw new Error('Command not mocked: ' + cmd);
             });
-            mockedExistsSync.mockReturnValue(false);
-            const result = await service.createWorktree('/path/to/worktree', 'new-feature', 'local-priority');
-            expect(result.success).toBe(true);
-            expect(mockedExecSync).toHaveBeenCalledWith('git worktree add -b "new-feature" "/path/to/worktree" "local-priority"', { cwd: '/fake/path', encoding: 'utf8' });
-            // Verify remote command was never called since local branch exists
-            expect(mockedExecSync).not.toHaveBeenCalledWith('git remote', expect.any(Object));
+            const effect = service.mergeWorktreeEffect('feature', 'main', false);
+            const result = await Effect.runPromise(Effect.either(effect));
+            if (result._tag === 'Left') {
+                expect(result.left).toBeInstanceOf(GitError);
+                expect(result.left.exitCode).toBe(1);
+                expect(result.left.stderr).toContain('Merge conflict');
+            }
+            else {
+                expect.fail('Should have returned Left with GitError');
+            }
         });
     });
 });