@aaronshaf/ger 0.1.0 → 0.1.3

package/tests/review.test.ts

@@ -1,89 +1,15 @@
-import { describe, test, expect, beforeEach, afterEach, mock, spyOn } from 'bun:test'
+import { describe, test, expect, beforeEach, afterEach, spyOn } from 'bun:test'
 import { Effect, Layer } from 'effect'
-import { reviewCommand } from '@/cli/commands/review'
-import { AiService, NoAiToolFoundError } from '@/services/ai'
-import { GerritApiService } from '@/api/gerrit'
-import { ConfigService } from '@/services/config'
-import { createMockConfigService } from './helpers/config-mock'
-import type { ChangeInfo, CommentInfo, MessageInfo } from '@/schemas/gerrit'
+import { GitWorktreeService, WorktreeCreationError } from '@/services/git-worktree'
 
-describe('Review Command', () => {
+describe('Review Command - Focused Tests', () => {
   let consoleSpy: any
-  let mockAiService: any
-  let mockApiService: any
 
   beforeEach(() => {
     consoleSpy = {
       log: spyOn(console, 'log').mockImplementation(() => {}),
       error: spyOn(console, 'error').mockImplementation(() => {}),
     }
-
-    // Mock AI Service
-    mockAiService = {
-      detectAiTool: () => Effect.succeed('claude'),
-      extractResponseTag: (output: string) => Effect.succeed(output),
-      runPrompt: (prompt: string, input: string) => {
-        if (
-          prompt.includes('JSON Structure for Inline Comments') ||
-          prompt.includes('Priority Guidelines for Inline Comments')
-        ) {
-          // Return mock inline comments
-          return Effect.succeed(
-            JSON.stringify([
-              {
-                file: 'src/main.ts',
-                line: 10,
-                message: '🤖 Consider adding error handling here',
-              },
-            ]),
-          )
-        } else {
-          // Return mock overall review
-          return Effect.succeed(
-            '🤖 Code Review\n\nOVERALL ASSESSMENT\n\nThe code looks good overall.',
-          )
-        }
-      },
-    }
-
-    // Mock Gerrit API Service
-    const mockChange: ChangeInfo = {
-      id: 'project~master~I123',
-      _number: 12345,
-      change_id: 'I123',
-      project: 'test-project',
-      branch: 'master',
-      subject: 'Test change',
-      status: 'NEW',
-      created: '2024-01-01 10:00:00.000000000',
-      updated: '2024-01-01 12:00:00.000000000',
-      owner: {
-        _account_id: 1000,
-        name: 'Test User',
-        email: 'test@example.com',
-      },
-    }
-
-    mockApiService = {
-      getChange: () => Effect.succeed(mockChange),
-      getDiff: () => Effect.succeed('diff --git a/src/main.ts b/src/main.ts\n+console.log("test")'),
-      getComments: () => Effect.succeed({} as Record<string, CommentInfo[]>),
-      getMessages: () => Effect.succeed([] as MessageInfo[]),
-      listChanges: () => Effect.fail({ _tag: 'ApiError' as const, message: 'Not implemented' }),
-      postReview: mock(() => Effect.succeed(undefined as void)),
-      abandonChange: () => Effect.fail({ _tag: 'ApiError' as const, message: 'Not implemented' }),
-      testConnection: Effect.succeed(true),
-      getRevision: () => Effect.fail({ _tag: 'ApiError' as const, message: 'Not implemented' }),
-      getFiles: () =>
-        Effect.succeed({
-          'src/main.ts': { status: 'M' as const },
-          'app/controllers/users_controller.rb': { status: 'M' as const },
-          'lib/utils/helper.rb': { status: 'A' as const },
-        }),
-      getFileDiff: () => Effect.fail({ _tag: 'ApiError' as const, message: 'Not implemented' }),
-      getFileContent: () => Effect.fail({ _tag: 'ApiError' as const, message: 'Not implemented' }),
-      getPatch: () => Effect.fail({ _tag: 'ApiError' as const, message: 'Not implemented' }),
-    }
   })
 
   afterEach(() => {
@@ -91,579 +17,119 @@ describe('Review Command', () => {
     consoleSpy.error.mockRestore()
   })
 
-  test('should detect AI tool and perform review', async () => {
-    const result = await Effect.runPromise(
-      Effect.either(
-        reviewCommand('12345', { debug: false }).pipe(
-          Effect.provide(Layer.succeed(AiService, mockAiService)),
-          Effect.provide(Layer.succeed(GerritApiService, mockApiService)),
-          Effect.provide(Layer.succeed(ConfigService, createMockConfigService())),
-        ),
-      ),
-    )
-
-    expect(result._tag).toBe('Right')
-
-    // Check that AI tool detection was logged
-    expect(consoleSpy.log).toHaveBeenCalledWith('→ Checking for AI tool availability...')
-    expect(consoleSpy.log).toHaveBeenCalledWith('✓ Found AI tool: claude')
-
-    // Check that review stages were executed
-    expect(consoleSpy.log).toHaveBeenCalledWith('→ Generating inline comments for change 12345...')
-    expect(consoleSpy.log).toHaveBeenCalledWith(
-      '→ Generating overall review comment for change 12345...',
-    )
-    expect(consoleSpy.log).toHaveBeenCalledWith('✓ Review complete for 12345')
-  })
-
-  test('should handle comment mode with auto-yes', async () => {
-    const result = await Effect.runPromise(
-      Effect.either(
-        reviewCommand('12345', { comment: true, yes: true }).pipe(
-          Effect.provide(Layer.succeed(AiService, mockAiService)),
-          Effect.provide(Layer.succeed(GerritApiService, mockApiService)),
-          Effect.provide(Layer.succeed(ConfigService, createMockConfigService())),
-        ),
-      ),
-    )
-
-    expect(result._tag).toBe('Right')
-
-    // Check that comments were posted without prompts
-    expect(consoleSpy.log).toHaveBeenCalledWith('✓ Inline comments posted for 12345')
-    expect(consoleSpy.log).toHaveBeenCalledWith('✓ Overall review posted for 12345')
-  })
-
-  test('should show debug output when debug flag is set', async () => {
-    const result = await Effect.runPromise(
-      Effect.either(
-        reviewCommand('12345', { debug: true }).pipe(
-          Effect.provide(Layer.succeed(AiService, mockAiService)),
-          Effect.provide(Layer.succeed(GerritApiService, mockApiService)),
-          Effect.provide(Layer.succeed(ConfigService, createMockConfigService())),
-        ),
-      ),
-    )
-
-    expect(result._tag).toBe('Right')
-
-    // Check that debug messages were shown
-    expect(consoleSpy.log).toHaveBeenCalledWith('[DEBUG] Running AI for inline comments...')
-    expect(consoleSpy.log).toHaveBeenCalledWith('[DEBUG] Running AI for overall review...')
-  })
-
-  test('should fail when no AI tool is available', async () => {
-    const noToolService = {
-      detectAiTool: () => Effect.fail(new NoAiToolFoundError({ message: 'No AI tool found' })),
-      extractResponseTag: mockAiService.extractResponseTag,
-      runPrompt: mockAiService.runPrompt,
-    }
-
-    const result = await Effect.runPromise(
-      Effect.either(
-        reviewCommand('12345', {}).pipe(
-          Effect.provide(Layer.succeed(AiService, noToolService)),
-          Effect.provide(Layer.succeed(GerritApiService, mockApiService)),
-          Effect.provide(Layer.succeed(ConfigService, createMockConfigService())),
-        ),
-      ),
-    )
-
-    expect(result._tag).toBe('Left')
-    if (result._tag === 'Left') {
-      expect(result.left).toBeInstanceOf(Error)
-      expect(result.left.message).toContain('No AI tool found')
-    }
-  })
-
-  test('should handle invalid JSON response for inline comments', async () => {
-    const badJsonService = {
-      detectAiTool: () => Effect.succeed('claude'),
-      extractResponseTag: (output: string) => Effect.succeed(output),
-      runPrompt: (prompt: string, input: string) => {
-        if (
-          prompt.includes('INLINE_REVIEW_SYSTEM_PROMPT') ||
-          prompt.includes('Example Output (THIS IS THE ONLY ACCEPTABLE FORMAT)')
-        ) {
-          // Return invalid JSON
-          return Effect.succeed('not valid json')
-        } else {
-          return Effect.succeed(
-            '🤖 Claude Code\n\nOVERALL ASSESSMENT\n\nThe code looks good overall.',
-          )
-        }
-      },
-    }
-
-    const result = await Effect.runPromise(
-      Effect.either(
-        reviewCommand('12345', {}).pipe(
-          Effect.provide(Layer.succeed(AiService, badJsonService)),
-          Effect.provide(Layer.succeed(GerritApiService, mockApiService)),
-          Effect.provide(Layer.succeed(ConfigService, createMockConfigService())),
-        ),
-      ),
-    )
-
-    expect(result._tag).toBe('Left')
-    expect(consoleSpy.error).toHaveBeenCalledWith(
-      expect.stringContaining('Failed to parse inline comments JSON'),
-    )
-  })
-
-  test('should handle empty inline comments array', async () => {
-    const emptyCommentsService = {
-      detectAiTool: () => Effect.succeed('claude'),
-      extractResponseTag: (output: string) => Effect.succeed(output),
-      runPrompt: (prompt: string, input: string) => {
-        if (
-          prompt.includes('JSON Structure for Inline Comments') ||
-          prompt.includes('Priority Guidelines for Inline Comments')
-        ) {
-          // Return empty array
-          return Effect.succeed('[]')
-        } else {
-          return Effect.succeed('🤖 Code Review\n\nOVERALL ASSESSMENT\n\nNo issues found.')
-        }
-      },
-    }
-
-    const result = await Effect.runPromise(
-      Effect.either(
-        reviewCommand('12345', {}).pipe(
-          Effect.provide(Layer.succeed(AiService, emptyCommentsService)),
-          Effect.provide(Layer.succeed(GerritApiService, mockApiService)),
-          Effect.provide(Layer.succeed(ConfigService, createMockConfigService())),
-        ),
-      ),
-    )
-
-    expect(result._tag).toBe('Right')
-    expect(consoleSpy.log).toHaveBeenCalledWith('\n→ No inline comments')
-  })
-
-  test('should format change data as XML for inline review', async () => {
-    let capturedXmlData: string | undefined
-
-    const captureService = {
-      detectAiTool: () => Effect.succeed('claude'),
-      extractResponseTag: (output: string) => Effect.succeed(output),
-      runPrompt: (prompt: string, input: string) => {
-        // Check if this is the inline review prompt (which gets XML data)
-        // Inline prompt contains "JSON Structure for Inline Comments" in its system prompt
-        if (prompt.includes('JSON Structure for Inline Comments')) {
-          capturedXmlData = input
-          return Effect.succeed('[]')
-        } else {
-          return Effect.succeed('🤖 Code Review\n\nOVERALL ASSESSMENT\n\nLooks good.')
-        }
-      },
-    }
-
-    await Effect.runPromise(
-      reviewCommand('12345', {}).pipe(
-        Effect.provide(Layer.succeed(AiService, captureService)),
-        Effect.provide(Layer.succeed(GerritApiService, mockApiService)),
-        Effect.provide(Layer.succeed(ConfigService, createMockConfigService())),
-      ),
-    )
-
-    expect(capturedXmlData).toBeDefined()
-    expect(capturedXmlData).toContain('<?xml version="1.0" encoding="UTF-8"?>')
-    expect(capturedXmlData).toContain('<show_result>')
-    expect(capturedXmlData).toContain('<change>')
-    expect(capturedXmlData).toContain('<id>I123</id>')
-    expect(capturedXmlData).toContain('<number>12345</number>')
-  })
-
-  test('should display review without posting when --comment flag is not present', async () => {
-    const result = await Effect.runPromise(
-      Effect.either(
-        reviewCommand('12345', {}).pipe(
-          Effect.provide(Layer.succeed(AiService, mockAiService)),
-          Effect.provide(Layer.succeed(GerritApiService, mockApiService)),
-          Effect.provide(Layer.succeed(ConfigService, createMockConfigService())),
-        ),
-      ),
-    )
-
-    expect(result._tag).toBe('Right')
-
-    // Check that it displays the reviews but doesn't post
-    expect(consoleSpy.log).toHaveBeenCalledWith(
-      expect.stringContaining('━━━━━━ INLINE COMMENTS ━━━━━━'),
-    )
-    expect(consoleSpy.log).toHaveBeenCalledWith(
-      expect.stringContaining('━━━━━━ OVERALL REVIEW ━━━━━━'),
-    )
-
-    // Verify it doesn't post
-    expect(consoleSpy.log).not.toHaveBeenCalledWith('✓ Inline comments posted for 12345')
-    expect(consoleSpy.log).not.toHaveBeenCalledWith('✓ Overall review posted for 12345')
-  })
-
-  test('should handle error during comment posting', async () => {
-    // Create a failing API service
-    const failingApiService = {
-      ...mockApiService,
-      postReview: () => Effect.fail({ _tag: 'ApiError' as const, message: 'Network error' }),
+  test('should integrate GitWorktreeService with review workflow', async () => {
+    // Mock Git Worktree Service
+    const mockGitService = {
+      validatePreconditions: () => Effect.succeed(undefined),
+      createWorktree: (changeId: string) =>
+        Effect.succeed({
+          path: `/tmp/test-worktree-${changeId}`,
+          changeId,
+          originalCwd: '/test/current',
+          timestamp: Date.now(),
+          pid: process.pid,
+        }),
+      fetchAndCheckoutPatchset: () => Effect.succeed(undefined),
+      cleanup: () => Effect.succeed(undefined),
+      getChangedFiles: () => Effect.succeed(['src/main.ts', 'tests/main.test.ts']),
     }
 
+    // Test the complete GitWorktreeService workflow
     const result = await Effect.runPromise(
-      Effect.either(
-        reviewCommand('12345', { comment: true, yes: true }).pipe(
-          Effect.provide(Layer.succeed(AiService, mockAiService)),
-          Effect.provide(Layer.succeed(GerritApiService, failingApiService)),
-          Effect.provide(Layer.succeed(ConfigService, createMockConfigService())),
-        ),
-      ),
-    )
-
-    expect(result._tag).toBe('Left')
-    expect(consoleSpy.error).toHaveBeenCalledWith(
-      expect.stringContaining('Failed to post inline comments'),
-    )
-  })
-
-  test('should format change data as pretty text for overall review', async () => {
-    let capturedPrettyData: string | undefined
-
-    const captureService = {
-      detectAiTool: () => Effect.succeed('claude'),
-      extractResponseTag: (output: string) => Effect.succeed(output),
-      runPrompt: (prompt: string, input: string) => {
-        // Check if this is the inline review prompt (which gets XML) or overall (which gets pretty text)
-        if (
-          prompt.includes('JSON Structure for Inline Comments') ||
-          prompt.includes('Priority Guidelines for Inline Comments')
-        ) {
-          // This is inline review with XML data
-          return Effect.succeed('[]')
-        } else if (prompt.includes('Review Structure and Formatting')) {
-          // This is overall review with pretty text data
-          capturedPrettyData = input
-          return Effect.succeed('🤖 Code Review\n\nOVERALL ASSESSMENT\n\nLooks good.')
-        } else {
-          return Effect.succeed('🤖 Code Review\n\nOVERALL ASSESSMENT\n\nLooks good.')
-        }
-      },
-    }
+      Effect.gen(function* () {
+        const service = yield* GitWorktreeService
 
-    await Effect.runPromise(
-      reviewCommand('12345', {}).pipe(
-        Effect.provide(Layer.succeed(AiService, captureService)),
-        Effect.provide(Layer.succeed(GerritApiService, mockApiService)),
-        Effect.provide(Layer.succeed(ConfigService, createMockConfigService())),
-      ),
-    )
-
-    expect(capturedPrettyData).toBeDefined()
-    expect(capturedPrettyData).toContain('📋 Change 12345: Test change')
-    expect(capturedPrettyData).toContain('Project: test-project')
-    expect(capturedPrettyData).toContain('Branch: master')
-    expect(capturedPrettyData).toContain('Status: NEW')
-  })
-
-  test('should use custom prompt file when --prompt option is provided', async () => {
-    const customPromptContent = 'Custom prompt for testing\n\nSpecial instructions here.'
-    const tempDir = require('os').tmpdir()
-    const tempFile = require('path').join(tempDir, `test-prompt-${Date.now()}.md`)
-
-    // Create temporary prompt file
-    require('fs').writeFileSync(tempFile, customPromptContent, 'utf8')
-
-    let capturedPrompt: string | undefined
-
-    const captureService = {
-      detectAiTool: () => Effect.succeed('claude'),
-      extractResponseTag: (output: string) => Effect.succeed(output),
-      runPrompt: (prompt: string, input: string) => {
-        capturedPrompt = prompt
-        if (prompt.includes('JSON Structure for Inline Comments')) {
-          return Effect.succeed('[]')
-        } else {
-          return Effect.succeed('🤖 Custom Review\n\nOVERALL ASSESSMENT\n\nUsed custom prompt.')
-        }
-      },
-    }
+        // Test precondition validation
+        yield* service.validatePreconditions()
 
-    try {
-      const result = await Effect.runPromise(
-        Effect.either(
-          reviewCommand('12345', { prompt: tempFile }).pipe(
-            Effect.provide(Layer.succeed(AiService, captureService)),
-            Effect.provide(Layer.succeed(GerritApiService, mockApiService)),
-            Effect.provide(Layer.succeed(ConfigService, createMockConfigService())),
-          ),
-        ),
-      )
+        // Test worktree creation
+        const worktree = yield* service.createWorktree('12345')
+        expect(worktree.changeId).toBe('12345')
+        expect(worktree.path).toContain('12345')
+        expect(worktree.originalCwd).toBe('/test/current')
 
-      expect(result._tag).toBe('Right')
-
-      // Check that custom prompt was loaded
-      expect(consoleSpy.log).toHaveBeenCalledWith(`✓ Using custom review prompt from ${tempFile}`)
-
-      // Verify the custom prompt content was used
-      expect(capturedPrompt).toContain(customPromptContent)
-    } finally {
-      // Clean up temporary file
-      require('fs').unlinkSync(tempFile)
-    }
-  })
-
-  test('should expand tilde (~/) in prompt file paths', async () => {
-    const customPromptContent = 'Home directory prompt test'
-    const homeDir = require('os').homedir()
-    const relativeFileName = `.test-prompt-${Date.now()}.md`
-    const absolutePath = require('path').join(homeDir, relativeFileName)
-    const tildePath = `~/${relativeFileName}`
-
-    // Create prompt file in home directory
-    require('fs').writeFileSync(absolutePath, customPromptContent, 'utf8')
-
-    let capturedPrompt: string | undefined
-
-    const captureService = {
-      detectAiTool: () => Effect.succeed('claude'),
-      extractResponseTag: (output: string) => Effect.succeed(output),
-      runPrompt: (prompt: string, input: string) => {
-        capturedPrompt = prompt
-        if (prompt.includes('JSON Structure for Inline Comments')) {
-          return Effect.succeed('[]')
-        } else {
-          return Effect.succeed('🤖 Home Prompt Review')
-        }
-      },
-    }
-
-    try {
-      const result = await Effect.runPromise(
-        Effect.either(
-          reviewCommand('12345', { prompt: tildePath }).pipe(
-            Effect.provide(Layer.succeed(AiService, captureService)),
-            Effect.provide(Layer.succeed(GerritApiService, mockApiService)),
-            Effect.provide(Layer.succeed(ConfigService, createMockConfigService())),
-          ),
-        ),
-      )
-
-      expect(result._tag).toBe('Right')
-
-      // Check that tilde path was correctly expanded and file was loaded
-      expect(consoleSpy.log).toHaveBeenCalledWith(`✓ Using custom review prompt from ${tildePath}`)
-      expect(capturedPrompt).toContain(customPromptContent)
-    } finally {
-      // Clean up
-      require('fs').unlinkSync(absolutePath)
-    }
-  })
-
-  test('should fallback to default prompt when custom prompt file is missing', async () => {
-    const nonExistentFile = '/tmp/does-not-exist-prompt.md'
-
-    let capturedPrompt: string | undefined
-
-    const captureService = {
-      detectAiTool: () => Effect.succeed('claude'),
-      extractResponseTag: (output: string) => Effect.succeed(output),
-      runPrompt: (prompt: string, input: string) => {
-        capturedPrompt = prompt
-        if (prompt.includes('JSON Structure for Inline Comments')) {
-          return Effect.succeed('[]')
-        } else {
-          return Effect.succeed('🤖 Default Review')
-        }
-      },
-    }
+        // Test patchset fetch
+        yield* service.fetchAndCheckoutPatchset(worktree)
 
-    const result = await Effect.runPromise(
-      Effect.either(
-        reviewCommand('12345', { prompt: nonExistentFile }).pipe(
-          Effect.provide(Layer.succeed(AiService, captureService)),
-          Effect.provide(Layer.succeed(GerritApiService, mockApiService)),
-          Effect.provide(Layer.succeed(ConfigService, createMockConfigService())),
-        ),
-      ),
-    )
+        // Test getting changed files
+        const files = yield* service.getChangedFiles()
+        expect(files).toEqual(['src/main.ts', 'tests/main.test.ts'])
 
-    expect(result._tag).toBe('Right')
+        // Test cleanup
+        yield* service.cleanup(worktree)
 
-    // Check that error was logged but execution continued
-    expect(consoleSpy.log).toHaveBeenCalledWith(
-      `⚠ Could not read custom prompt file: ${nonExistentFile}`,
+        return { success: true, worktree, files }
+      }).pipe(Effect.provide(Layer.succeed(GitWorktreeService, mockGitService))),
     )
-    expect(consoleSpy.log).toHaveBeenCalledWith('→ Using default review prompt')
 
-    // Verify default prompt was used (should not contain custom content)
-    expect(capturedPrompt).toContain('Code Review Guidelines')
+    // Verify the workflow completed successfully
+    expect(result.success).toBe(true)
+    expect(result.worktree.path).toContain('12345')
+    expect(result.files).toHaveLength(2)
+    expect(result.files).toEqual(['src/main.ts', 'tests/main.test.ts'])
   })
 
-  test('should handle permission errors gracefully for custom prompt files', async () => {
-    const restrictedDir = '/root' // Directory that typically has restricted permissions
-    const restrictedFile = `${restrictedDir}/test-prompt.md`
-
-    let capturedPrompt: string | undefined
-
-    const captureService = {
-      detectAiTool: () => Effect.succeed('claude'),
-      extractResponseTag: (output: string) => Effect.succeed(output),
-      runPrompt: (prompt: string, input: string) => {
-        capturedPrompt = prompt
-        if (prompt.includes('JSON Structure for Inline Comments')) {
-          return Effect.succeed('[]')
-        } else {
-          return Effect.succeed('🤖 Default Review')
-        }
-      },
-    }
-
-    const result = await Effect.runPromise(
-      Effect.either(
-        reviewCommand('12345', { prompt: restrictedFile }).pipe(
-          Effect.provide(Layer.succeed(AiService, captureService)),
-          Effect.provide(Layer.succeed(GerritApiService, mockApiService)),
-          Effect.provide(Layer.succeed(ConfigService, createMockConfigService())),
-        ),
+  test('should handle concurrent worktree scenarios with unique paths', async () => {
+    const mockGitService = {
+      validatePreconditions: () => Effect.succeed(undefined),
+      createWorktree: (changeId: string) =>
+        Effect.succeed({
+          path: `/tmp/test-worktree-${changeId}-${Date.now()}-${process.pid}`,
+          changeId,
+          originalCwd: process.cwd(),
+          timestamp: Date.now(),
+          pid: process.pid,
+        }),
+      fetchAndCheckoutPatchset: () => Effect.succeed(undefined),
+      cleanup: () => Effect.succeed(undefined),
+      getChangedFiles: () => Effect.succeed(['test.ts']),
+    }
+
+    // Simulate concurrent worktree creation
+    const [result1, result2] = await Promise.all([
+      Effect.runPromise(
+        Effect.gen(function* () {
+          const service = yield* GitWorktreeService
+          return yield* service.createWorktree('change-1')
+        }).pipe(Effect.provide(Layer.succeed(GitWorktreeService, mockGitService))),
       ),
-    )
-
-    expect(result._tag).toBe('Right')
-
-    // Should fallback gracefully without crashing
-    expect(consoleSpy.log).toHaveBeenCalledWith(
-      `⚠ Could not read custom prompt file: ${restrictedFile}`,
-    )
-    expect(consoleSpy.log).toHaveBeenCalledWith('→ Using default review prompt')
-  })
-
-  test('should work normally without --prompt option (default behavior)', async () => {
-    let capturedPrompt: string | undefined
-
-    const captureService = {
-      detectAiTool: () => Effect.succeed('claude'),
-      extractResponseTag: (output: string) => Effect.succeed(output),
-      runPrompt: (prompt: string, input: string) => {
-        capturedPrompt = prompt
-        if (prompt.includes('JSON Structure for Inline Comments')) {
-          return Effect.succeed('[]')
-        } else {
-          return Effect.succeed('🤖 Default Review')
-        }
-      },
-    }
-
-    const result = await Effect.runPromise(
-      Effect.either(
-        reviewCommand('12345', {}).pipe(
-          Effect.provide(Layer.succeed(AiService, captureService)),
-          Effect.provide(Layer.succeed(GerritApiService, mockApiService)),
-          Effect.provide(Layer.succeed(ConfigService, createMockConfigService())),
-        ),
+      Effect.runPromise(
+        Effect.gen(function* () {
+          const service = yield* GitWorktreeService
+          return yield* service.createWorktree('change-2')
+        }).pipe(Effect.provide(Layer.succeed(GitWorktreeService, mockGitService))),
       ),
-    )
-
-    expect(result._tag).toBe('Right')
+    ])
 
-    // Should not show any custom prompt messages
-    expect(consoleSpy.log).not.toHaveBeenCalledWith(
-      expect.stringContaining('Using custom review prompt'),
-    )
-    expect(consoleSpy.log).not.toHaveBeenCalledWith(
-      expect.stringContaining('Could not read custom prompt file'),
-    )
-
-    // Should use default review prompt
-    expect(capturedPrompt).toContain('Code Review Guidelines')
+    // Verify both worktrees have unique paths
+    expect(result1.path).not.toBe(result2.path)
+    expect(result1.changeId).toBe('change-1')
+    expect(result2.changeId).toBe('change-2')
   })
 
-  test('should validate and fix inline comment file paths', async () => {
-    const aiService = {
-      detectAiTool: () => Effect.succeed('claude'),
-      extractResponseTag: (output: string) => Effect.succeed(output),
-      runPrompt: (prompt: string, input: string) => {
-        if (prompt.includes('JSON Structure for Inline Comments')) {
-          // Return comments with incomplete file paths that need fixing
-          return Effect.succeed(
-            JSON.stringify([
-              {
-                file: 'users_controller.rb',
-                line: 10,
-                message: '🤖 Test comment with incomplete path',
-              },
-              {
-                file: 'app/controllers/users_controller.rb',
-                line: 20,
-                message: '🤖 Test comment with complete path',
-              },
-              { file: 'nonexistent.rb', line: 30, message: '🤖 Test comment for nonexistent file' },
-              { file: 'helper.rb', line: 40, message: '🤖 Test comment with partial path' },
-            ]),
-          )
-        }
-        return Effect.succeed('Overall review comment')
-      },
+  test('should handle error scenarios in worktree operations', async () => {
+    const failingGitService = {
+      validatePreconditions: () =>
+        Effect.fail(new WorktreeCreationError({ message: 'Git repository validation failed' })),
+      createWorktree: () =>
+        Effect.fail(new WorktreeCreationError({ message: 'Worktree creation failed' })),
+      fetchAndCheckoutPatchset: () =>
+        Effect.fail(new WorktreeCreationError({ message: 'Patchset fetch failed' })),
+      cleanup: () => Effect.succeed(undefined), // Cleanup should never fail
+      getChangedFiles: () => Effect.fail(new WorktreeCreationError({ message: 'Git diff failed' })),
     }
 
-    const result = await Effect.runPromiseExit(
-      reviewCommand('12345', { comment: true, yes: true }).pipe(
-        Effect.provide(Layer.succeed(AiService, aiService)),
-        Effect.provide(Layer.succeed(GerritApiService, mockApiService)),
-        Effect.provide(Layer.succeed(ConfigService, createMockConfigService())),
-      ),
+    // Test validation failure
+    const validationResult = await Effect.runPromiseExit(
+      Effect.gen(function* () {
+        const service = yield* GitWorktreeService
+        yield* service.validatePreconditions()
+      }).pipe(Effect.provide(Layer.succeed(GitWorktreeService, failingGitService))),
     )
 
-    expect(result._tag).toBe('Success')
-
-    // Verify that the postReview was called (meaning some comments were valid after validation)
-    expect(mockApiService.postReview).toHaveBeenCalled()
-  })
-
-  test('should combine custom prompt with system prompts correctly', async () => {
-    const customPromptContent = 'CUSTOM: Focus on security issues\nAnd performance concerns'
-    const tempDir = require('os').tmpdir()
-    const tempFile = require('path').join(tempDir, `test-combine-prompt-${Date.now()}.md`)
-
-    require('fs').writeFileSync(tempFile, customPromptContent, 'utf8')
-
-    let inlinePromptCaptured: string | undefined
-    let overallPromptCaptured: string | undefined
-
-    const captureService = {
-      detectAiTool: () => Effect.succeed('claude'),
-      extractResponseTag: (output: string) => Effect.succeed(output),
-      runPrompt: (prompt: string, input: string) => {
-        if (prompt.includes('JSON Structure for Inline Comments')) {
-          inlinePromptCaptured = prompt
-          return Effect.succeed('[]')
-        } else {
-          overallPromptCaptured = prompt
-          return Effect.succeed('🤖 Combined Review')
-        }
-      },
-    }
-
-    try {
-      const result = await Effect.runPromise(
-        Effect.either(
-          reviewCommand('12345', { prompt: tempFile }).pipe(
-            Effect.provide(Layer.succeed(AiService, captureService)),
-            Effect.provide(Layer.succeed(GerritApiService, mockApiService)),
-            Effect.provide(Layer.succeed(ConfigService, createMockConfigService())),
-          ),
-        ),
-      )
-
-      expect(result._tag).toBe('Right')
-
-      // Both inline and overall prompts should contain custom content
-      expect(inlinePromptCaptured).toContain(customPromptContent)
-      expect(overallPromptCaptured).toContain(customPromptContent)
-
-      // Both should also contain their respective system prompts
-      expect(inlinePromptCaptured).toContain('JSON Structure for Inline Comments')
-      expect(overallPromptCaptured).toContain('Review Structure and Formatting')
-    } finally {
-      require('fs').unlinkSync(tempFile)
+    expect(validationResult._tag).toBe('Failure')
+    if (validationResult._tag === 'Failure') {
+      expect(String(validationResult.cause)).toContain('Git repository validation failed')
     }
   })
 })