@aaronshaf/ger 0.1.0 → 0.1.3

package/tests/unit/git-branch-detection.test.ts

@@ -0,0 +1,83 @@
+import { describe, test, expect } from 'bun:test'
+import { Effect, Layer } from 'effect'
+import { GitWorktreeService, GitWorktreeServiceLive } from '@/services/git-worktree'
+
+describe('Git Worktree Creation', () => {
+  test('should handle commit-based worktree creation in service interface', async () => {
+    // This test verifies that the GitWorktreeService creates worktrees using
+    // commit hashes to avoid branch conflicts (detached HEAD approach)
+
+    const mockGitService = {
+      validatePreconditions: () => Effect.succeed(undefined),
+      createWorktree: (changeId: string) => {
+        // Simulate commit-based worktree creation (detached HEAD)
+        const currentCommit = 'abc123def456' // Mock commit hash
+        return Effect.succeed({
+          path: `/tmp/test-worktree-${changeId}`,
+          changeId,
+          originalCwd: process.cwd(),
+          timestamp: Date.now(),
+          pid: process.pid,
+        })
+      },
+      fetchAndCheckoutPatchset: () => Effect.succeed(undefined),
+      cleanup: () => Effect.succeed(undefined),
+      getChangedFiles: () => Effect.succeed(['test.ts']),
+    }
+
+    const result = await Effect.runPromise(
+      Effect.gen(function* () {
+        const service = yield* GitWorktreeService
+
+        // This call should work without specifying a base branch
+        // The implementation will auto-detect main vs master vs other
+        const worktree = yield* service.createWorktree('12345')
+
+        return worktree
+      }).pipe(Effect.provide(Layer.succeed(GitWorktreeService, mockGitService))),
+    )
+
+    expect(result.changeId).toBe('12345')
+    expect(result.path).toContain('12345')
+  })
+
+  test('should demonstrate branch detection scenarios', () => {
+    // Test various branch detection patterns that the real implementation should handle
+    const testCases = [
+      { input: 'refs/remotes/origin/main', expected: 'main' },
+      { input: 'refs/remotes/origin/master', expected: 'master' },
+      { input: 'refs/remotes/origin/develop', expected: 'develop' },
+    ]
+
+    testCases.forEach(({ input, expected }) => {
+      // Simulate the regex pattern used in getDefaultBranch
+      const match = input.match(/refs\/remotes\/origin\/(.+)$/)
+      const result = match ? match[1] : 'main'
+      expect(result).toBe(expected)
+    })
+  })
+
+  test('should handle branch list parsing scenarios', () => {
+    // Test branch list parsing scenarios
+    const testCases = [
+      { input: '  origin/main\n  origin/feature-branch', expected: 'main' },
+      { input: '  origin/master\n  origin/develop', expected: 'master' },
+      { input: '  origin/main\n  origin/master', expected: 'main' }, // main takes precedence
+      { input: '  origin/feature-only', expected: 'main' }, // fallback
+      { input: '', expected: 'main' }, // empty fallback
+    ]
+
+    testCases.forEach(({ input, expected }) => {
+      // Simulate the branch detection logic
+      let result: string
+      if (input.includes('origin/main')) {
+        result = 'main'
+      } else if (input.includes('origin/master')) {
+        result = 'master'
+      } else {
+        result = 'main' // fallback
+      }
+      expect(result).toBe(expected)
+    })
+  })
+})

package/tests/unit/git-worktree.test.ts

@@ -0,0 +1,54 @@
+import { describe, test, expect } from 'bun:test'
+import { Effect, Layer } from 'effect'
+import { GitWorktreeService, WorktreeInfo } from '@/services/git-worktree'
+
+describe('GitWorktreeService Types and Structure', () => {
+  test('should export WorktreeInfo interface with correct structure', () => {
+    const mockWorktreeInfo: WorktreeInfo = {
+      path: '/tmp/test-worktree',
+      changeId: '12345',
+      originalCwd: '/test/current',
+      timestamp: Date.now(),
+      pid: process.pid,
+    }
+
+    expect(mockWorktreeInfo.path).toBe('/tmp/test-worktree')
+    expect(mockWorktreeInfo.changeId).toBe('12345')
+    expect(mockWorktreeInfo.originalCwd).toBe('/test/current')
+    expect(typeof mockWorktreeInfo.timestamp).toBe('number')
+    expect(typeof mockWorktreeInfo.pid).toBe('number')
+  })
+
+  test('should create service tag correctly', () => {
+    expect(GitWorktreeService).toBeDefined()
+    expect(typeof GitWorktreeService).toBe('function')
+  })
+
+  test('should be able to create mock service implementation', async () => {
+    const mockService = {
+      validatePreconditions: () => Effect.succeed(undefined),
+      createWorktree: (changeId: string) =>
+        Effect.succeed({
+          path: `/tmp/test-worktree-${changeId}`,
+          changeId,
+          originalCwd: process.cwd(),
+          timestamp: Date.now(),
+          pid: process.pid,
+        }),
+      fetchAndCheckoutPatchset: () => Effect.succeed(undefined),
+      cleanup: () => Effect.succeed(undefined),
+      getChangedFiles: () => Effect.succeed(['test.ts']),
+    }
+
+    const result = await Effect.runPromise(
+      Effect.gen(function* () {
+        const service = yield* GitWorktreeService
+        const worktree = yield* service.createWorktree('12345')
+        return worktree
+      }).pipe(Effect.provide(Layer.succeed(GitWorktreeService, mockService))),
+    )
+
+    expect(result.changeId).toBe('12345')
+    expect(result.path).toContain('12345')
+  })
+})

package/tests/unit/services/review-strategy.test.ts

@@ -0,0 +1,494 @@
+import { describe, it, expect, beforeEach, mock } from 'bun:test'
+import { Effect } from 'effect'
+
+// Create testable versions of the strategies by injecting dependencies
+interface MockDeps {
+  execAsync: (cmd: string) => Promise<{ stdout: string; stderr: string }>
+  spawn: (command: string, options: any) => any
+}
+
+// Mock for Claude SDK
+interface MockClaudeSDK {
+  query: any // Will be a Bun mock function
+}
+
+// Test implementation that mirrors the real strategy structure
+const createTestStrategy = (name: string, command: string, flags: string[], deps: MockDeps) => ({
+  name,
+  isAvailable: () =>
+    Effect.gen(function* () {
+      try {
+        const result = yield* Effect.tryPromise({
+          try: () => deps.execAsync(`which ${command.split(' ')[0]}`),
+          catch: () => null,
+        }).pipe(Effect.orElseSucceed(() => null))
+
+        return Boolean(result && result.stdout.trim())
+      } catch {
+        return false
+      }
+    }),
+  executeReview: (prompt: string, options: { cwd?: string } = {}) =>
+    Effect.gen(function* () {
+      const result = yield* Effect.tryPromise({
+        try: async () => {
+          const child = deps.spawn(`${command} ${flags.join(' ')}`, {
+            shell: true,
+            stdio: ['pipe', 'pipe', 'pipe'],
+            cwd: options.cwd || process.cwd(),
+          })
+
+          child.stdin.write(prompt)
+          child.stdin.end()
+
+          let stdout = ''
+          let stderr = ''
+
+          child.stdout.on('data', (data: Buffer) => {
+            stdout += data.toString()
+          })
+
+          child.stderr.on('data', (data: Buffer) => {
+            stderr += data.toString()
+          })
+
+          return new Promise<{ stdout: string; stderr: string }>((resolve, reject) => {
+            child.on('close', (code: number) => {
+              if (code !== 0) {
+                reject(new Error(`${name} exited with code ${code}: ${stderr}`))
+              } else {
+                resolve({ stdout, stderr })
+              }
+            })
+
+            child.on('error', reject)
+          })
+        },
+        catch: (error) =>
+          new Error(`${name} failed: ${error instanceof Error ? error.message : String(error)}`),
+      })
+
+      // Extract response from <response> tags or use full output
+      const responseMatch = result.stdout.match(/<response>([\s\S]*?)<\/response>/i)
+      return responseMatch ? responseMatch[1].trim() : result.stdout.trim()
+    }),
+})
+
+// Test implementation for Claude SDK strategy
+const createSDKStrategy = (
+  name: string,
+  deps: { sdk: MockClaudeSDK | null; hasApiKey: boolean },
+) => ({
+  name,
+  isAvailable: () =>
+    Effect.gen(function* () {
+      return Boolean(deps.sdk && deps.hasApiKey)
+    }),
+  executeReview: (prompt: string, options: { cwd?: string; systemPrompt?: string } = {}) =>
+    Effect.gen(function* () {
+      if (!deps.sdk) {
+        return yield* Effect.fail(new Error(`${name} not available`))
+      }
+
+      const result = yield* Effect.tryPromise({
+        try: async () => {
+          for await (const message of deps.sdk!.query({
+            prompt,
+            options: {
+              maxTurns: 3,
+              customSystemPrompt: options.systemPrompt || 'You are a code review expert.',
+              allowedTools: ['Read', 'Grep', 'Glob'],
+              cwd: options.cwd,
+            },
+          })) {
+            if (message.type === 'result' && message.subtype === 'success' && message.result) {
+              return message.result
+            }
+          }
+          throw new Error('No result received')
+        },
+        catch: (error) =>
+          new Error(`${name} failed: ${error instanceof Error ? error.message : String(error)}`),
+      })
+
+      return result
+    }),
+})
+
+describe('Review Strategy', () => {
+  let mockExecAsync: any
+  let mockSpawn: any
+  let mockChildProcess: any
+
+  beforeEach(() => {
+    mockChildProcess = {
+      stdin: {
+        write: mock(() => {}),
+        end: mock(() => {}),
+      },
+      stdout: {
+        on: mock(() => {}),
+      },
+      stderr: {
+        on: mock(() => {}),
+      },
+      on: mock(() => {}),
+    }
+
+    mockExecAsync = mock()
+    mockSpawn = mock(() => mockChildProcess)
+  })
+
+  const setupSuccessfulExecution = (output = 'AI response') => {
+    mockChildProcess.stdout.on.mockImplementation((event: string, callback: Function) => {
+      if (event === 'data') {
+        process.nextTick(() => callback(Buffer.from(output)))
+      }
+    })
+
+    mockChildProcess.stderr.on.mockImplementation((event: string, callback: Function) => {
+      // No stderr for success
+    })
+
+    mockChildProcess.on.mockImplementation((event: string, callback: Function) => {
+      if (event === 'close') {
+        process.nextTick(() => callback(0))
+      }
+    })
+  }
+
+  const setupFailedExecution = (exitCode = 1, stderr = 'Command failed') => {
+    mockChildProcess.stdout.on.mockImplementation((event: string, callback: Function) => {
+      // No stdout for failure
+    })
+
+    mockChildProcess.stderr.on.mockImplementation((event: string, callback: Function) => {
+      if (event === 'data') {
+        process.nextTick(() => callback(Buffer.from(stderr)))
+      }
+    })
+
+    mockChildProcess.on.mockImplementation((event: string, callback: Function) => {
+      if (event === 'close') {
+        process.nextTick(() => callback(exitCode))
+      }
+    })
+  }
+
+  describe('Claude CLI Strategy', () => {
+    let claudeStrategy: any
+
+    beforeEach(() => {
+      claudeStrategy = createTestStrategy('Claude CLI', 'claude', ['-p'], {
+        execAsync: mockExecAsync,
+        spawn: mockSpawn,
+      })
+    })
+
+    it('should check availability when claude is installed', async () => {
+      mockExecAsync.mockResolvedValueOnce({ stdout: '/usr/local/bin/claude', stderr: '' })
+
+      const available = await Effect.runPromise(claudeStrategy.isAvailable())
+
+      expect(available).toBe(true)
+      expect(mockExecAsync).toHaveBeenCalledWith('which claude')
+    })
+
+    it('should check availability when claude is not installed', async () => {
+      mockExecAsync.mockRejectedValueOnce(new Error('Command not found'))
+
+      const available = await Effect.runPromise(claudeStrategy.isAvailable())
+
+      expect(available).toBe(false)
+    })
+
+    it('should execute review successfully', async () => {
+      setupSuccessfulExecution('Claude AI response')
+
+      const response = await Effect.runPromise(
+        claudeStrategy.executeReview('Test prompt', { cwd: '/tmp' }),
+      )
+
+      expect(response).toBe('Claude AI response')
+      expect(mockSpawn).toHaveBeenCalledWith('claude -p', {
+        shell: true,
+        stdio: ['pipe', 'pipe', 'pipe'],
+        cwd: '/tmp',
+      })
+      expect(mockChildProcess.stdin.write).toHaveBeenCalledWith('Test prompt')
+      expect(mockChildProcess.stdin.end).toHaveBeenCalled()
+    })
+
+    it('should extract response from tags', async () => {
+      setupSuccessfulExecution('<response>Tagged content</response>')
+
+      const response = await Effect.runPromise(claudeStrategy.executeReview('Test prompt'))
+
+      expect(response).toBe('Tagged content')
+    })
+
+    it('should handle command failures', async () => {
+      setupFailedExecution(1, 'Claude CLI error')
+
+      try {
+        await Effect.runPromise(claudeStrategy.executeReview('Test prompt'))
+        expect(false).toBe(true) // Should not reach here
+      } catch (error: any) {
+        expect(error.message).toContain('Claude CLI failed')
+      }
+    })
+  })
+
+  describe('Gemini CLI Strategy', () => {
+    let geminiStrategy: any
+
+    beforeEach(() => {
+      geminiStrategy = createTestStrategy('Gemini CLI', 'gemini', ['-p'], {
+        execAsync: mockExecAsync,
+        spawn: mockSpawn,
+      })
+    })
+
+    it('should check availability', async () => {
+      mockExecAsync.mockResolvedValueOnce({ stdout: '/usr/local/bin/gemini', stderr: '' })
+
+      const available = await Effect.runPromise(geminiStrategy.isAvailable())
+
+      expect(available).toBe(true)
+      expect(mockExecAsync).toHaveBeenCalledWith('which gemini')
+    })
+
+    it('should use -p flag', async () => {
+      setupSuccessfulExecution('Gemini response')
+
+      const response = await Effect.runPromise(geminiStrategy.executeReview('Test prompt'))
+
+      expect(response).toBe('Gemini response')
+      expect(mockSpawn).toHaveBeenCalledWith('gemini -p', expect.any(Object))
+    })
+  })
+
+  describe('OpenCode CLI Strategy', () => {
+    let opencodeStrategy: any
+
+    beforeEach(() => {
+      opencodeStrategy = createTestStrategy('OpenCode CLI', 'opencode', ['-p'], {
+        execAsync: mockExecAsync,
+        spawn: mockSpawn,
+      })
+    })
+
+    it('should check availability', async () => {
+      mockExecAsync.mockResolvedValueOnce({ stdout: '/usr/local/bin/opencode', stderr: '' })
+
+      const available = await Effect.runPromise(opencodeStrategy.isAvailable())
+
+      expect(available).toBe(true)
+      expect(mockExecAsync).toHaveBeenCalledWith('which opencode')
+    })
+
+    it('should use -p flag', async () => {
+      setupSuccessfulExecution('OpenCode response')
+
+      const response = await Effect.runPromise(opencodeStrategy.executeReview('Test prompt'))
+
+      expect(response).toBe('OpenCode response')
+      expect(mockSpawn).toHaveBeenCalledWith('opencode -p', expect.any(Object))
+    })
+  })
+
+  describe('Claude SDK Strategy', () => {
+    let mockSDK: MockClaudeSDK
+    let claudeSDKStrategy: any
+
+    beforeEach(() => {
+      mockSDK = {
+        query: mock(),
+      }
+
+      claudeSDKStrategy = createSDKStrategy('Claude SDK', {
+        sdk: mockSDK,
+        hasApiKey: true,
+      })
+    })
+
+    it('should check availability when SDK and API key are present', async () => {
+      const available = await Effect.runPromise(claudeSDKStrategy.isAvailable())
+
+      expect(available).toBe(true)
+    })
+
+    it('should check availability when SDK is missing', async () => {
+      const strategy = createSDKStrategy('Claude SDK', {
+        sdk: null,
+        hasApiKey: true,
+      })
+
+      const available = await Effect.runPromise(strategy.isAvailable())
+
+      expect(available).toBe(false)
+    })
+
+    it('should check availability when API key is missing', async () => {
+      const strategy = createSDKStrategy('Claude SDK', {
+        sdk: mockSDK,
+        hasApiKey: false,
+      })
+
+      const available = await Effect.runPromise(strategy.isAvailable())
+
+      expect(available).toBe(false)
+    })
+
+    it('should execute review successfully', async () => {
+      mockSDK.query = mock(async function* () {
+        yield { type: 'message', content: 'Thinking...' }
+        yield { type: 'result', subtype: 'success', result: 'Claude SDK response' }
+      })
+
+      const response = await Effect.runPromise(
+        claudeSDKStrategy.executeReview('Test prompt', { cwd: '/tmp' }),
+      )
+
+      expect(response).toBe('Claude SDK response')
+      expect(mockSDK.query).toHaveBeenCalledWith({
+        prompt: 'Test prompt',
+        options: {
+          maxTurns: 3,
+          customSystemPrompt: 'You are a code review expert.',
+          allowedTools: ['Read', 'Grep', 'Glob'],
+          cwd: '/tmp',
+        },
+      })
+    })
+
+    it('should use custom system prompt', async () => {
+      mockSDK.query = mock(async function* () {
+        yield { type: 'result', subtype: 'success', result: 'Custom prompt response' }
+      })
+
+      const response = await Effect.runPromise(
+        claudeSDKStrategy.executeReview('Test prompt', {
+          systemPrompt: 'Custom review prompt',
+        }),
+      )
+
+      expect(response).toBe('Custom prompt response')
+      expect(mockSDK.query).toHaveBeenCalledWith({
+        prompt: 'Test prompt',
+        options: {
+          maxTurns: 3,
+          customSystemPrompt: 'Custom review prompt',
+          allowedTools: ['Read', 'Grep', 'Glob'],
+          cwd: undefined,
+        },
+      })
+    })
+
+    it('should handle SDK failure', async () => {
+      mockSDK.query = mock(async function* () {
+        throw new Error('SDK error')
+      })
+
+      try {
+        await Effect.runPromise(claudeSDKStrategy.executeReview('Test prompt'))
+        expect(false).toBe(true) // Should not reach here
+      } catch (error: any) {
+        expect(error.message).toContain('Claude SDK failed')
+      }
+    })
+
+    it('should handle no result received', async () => {
+      mockSDK.query = mock(async function* () {
+        yield { type: 'message', content: 'No result' }
+      })
+
+      try {
+        await Effect.runPromise(claudeSDKStrategy.executeReview('Test prompt'))
+        expect(false).toBe(true) // Should not reach here
+      } catch (error: any) {
+        expect(error.message).toContain('No result received')
+      }
+    })
+  })
+
+  describe('Integration with actual service patterns', () => {
+    it('should demonstrate proper Effect patterns', async () => {
+      const mockStrategy = createTestStrategy('Mock CLI', 'mock', [], {
+        execAsync: mockExecAsync,
+        spawn: mockSpawn,
+      })
+
+      setupSuccessfulExecution('Integration test response')
+
+      // Test using Effect.gen patterns like the real service
+      const result = await Effect.runPromise(
+        Effect.gen(function* () {
+          // Test availability check
+          mockExecAsync.mockResolvedValueOnce({ stdout: '/usr/local/bin/mock', stderr: '' })
+          const available = yield* mockStrategy.isAvailable()
+
+          if (!available) {
+            return yield* Effect.fail(new Error('Strategy not available'))
+          }
+
+          // Test execution
+          const response = yield* mockStrategy.executeReview('Test prompt', { cwd: '/tmp' })
+          return response
+        }),
+      )
+
+      expect(result).toBe('Integration test response')
+    })
+
+    it('should handle error propagation correctly', async () => {
+      const mockStrategy = createTestStrategy('Failing CLI', 'failing', [], {
+        execAsync: mockExecAsync,
+        spawn: mockSpawn,
+      })
+
+      setupFailedExecution(1, 'Mock failure')
+
+      try {
+        await Effect.runPromise(
+          Effect.gen(function* () {
+            return yield* mockStrategy.executeReview('Test prompt')
+          }),
+        )
+        expect(false).toBe(true) // Should not reach here
+      } catch (error: any) {
+        expect(error.message).toContain('Failing CLI failed')
+      }
+    })
+
+    it('should test multiple strategy selection logic', async () => {
+      const strategies = [
+        createTestStrategy('Strategy A', 'a', [], { execAsync: mockExecAsync, spawn: mockSpawn }),
+        createTestStrategy('Strategy B', 'b', [], { execAsync: mockExecAsync, spawn: mockSpawn }),
+        createTestStrategy('Strategy C', 'c', [], { execAsync: mockExecAsync, spawn: mockSpawn }),
+      ]
+
+      // Mock availability checks: A fails, B succeeds, C succeeds
+      mockExecAsync
+        .mockRejectedValueOnce(new Error('Command not found')) // A not available
+        .mockResolvedValueOnce({ stdout: '/usr/local/bin/b', stderr: '' }) // B available
+        .mockResolvedValueOnce({ stdout: '/usr/local/bin/c', stderr: '' }) // C available
+
+      const available = await Effect.runPromise(
+        Effect.gen(function* () {
+          const availableStrategies = []
+          for (const strategy of strategies) {
+            const isAvailable = yield* strategy.isAvailable()
+            if (isAvailable) {
+              availableStrategies.push(strategy)
+            }
+          }
+          return availableStrategies
+        }),
+      )
+
+      expect(available.length).toBe(2)
+      expect(available.map((s) => s.name)).toEqual(['Strategy B', 'Strategy C'])
+    })
+  })
+})