@aaronshaf/ger 0.1.0

package/tests/abandon.test.ts

@@ -0,0 +1,163 @@
+import { beforeEach, describe, expect, it, mock } from 'bun:test'
+import type { ChangeInfo } from '@/schemas/gerrit'
+
+const mockChange: ChangeInfo = {
+  id: 'test-project~master~I123',
+  _number: 12345,
+  change_id: 'I123',
+  project: 'test-project',
+  branch: 'master',
+  subject: 'Test change to abandon',
+  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',
+  },
+  labels: {
+    'Code-Review': {
+      value: 0,
+    },
+    Verified: {
+      value: 0,
+    },
+  },
+  work_in_progress: false,
+  submittable: false,
+}
+
+describe('abandon command', () => {
+  let mockFetch: ReturnType<typeof mock>
+
+  beforeEach(() => {
+    // Reset fetch mock for each test
+    mockFetch = mock(() =>
+      Promise.resolve({
+        ok: true,
+        status: 200,
+        text: () => Promise.resolve(')]}\n{}'),
+      }),
+    )
+    global.fetch = mockFetch as unknown as typeof fetch
+  })
+
+  it('should call abandon API endpoint with correct parameters', async () => {
+    // Mock successful responses
+    mockFetch
+      .mockResolvedValueOnce({
+        ok: true,
+        text: async () => `)]}'
+{
+  "id": "test-project~master~I123",
+  "project": "test-project",
+  "branch": "master",
+  "change_id": "I123",
+  "subject": "Test change to abandon",
+  "status": "NEW",
+  "_number": 12345
+}`,
+      })
+      .mockResolvedValueOnce({
+        ok: true,
+        text: async () => ')]}\n{}',
+      })
+
+    // Note: This is a unit test demonstrating the API calls
+    // Actual integration would require running the full command
+    // which we avoid to prevent hitting production
+
+    // Verify the mock setup
+    const response = await mockFetch('https://test.gerrit.com/a/changes/12345')
+    const text = await response.text()
+    expect(text).toContain('Test change to abandon')
+
+    // Verify abandon endpoint would be called
+    const abandonResponse = await mockFetch('https://test.gerrit.com/a/changes/12345/abandon', {
+      method: 'POST',
+      body: JSON.stringify({ message: 'No longer needed' }),
+    })
+    expect(abandonResponse.ok).toBe(true)
+
+    // Verify calls were made
+    expect(mockFetch).toHaveBeenCalledTimes(2)
+  })
+
+  it('should handle abandon without message', async () => {
+    mockFetch.mockResolvedValueOnce({
+      ok: true,
+      text: async () => ')]}\n{}',
+    })
+
+    const response = await mockFetch('https://test.gerrit.com/a/changes/12345/abandon', {
+      method: 'POST',
+      body: JSON.stringify({}),
+    })
+
+    expect(response.ok).toBe(true)
+    expect(mockFetch).toHaveBeenCalledWith('https://test.gerrit.com/a/changes/12345/abandon', {
+      method: 'POST',
+      body: JSON.stringify({}),
+    })
+  })
+
+  it('should handle API errors', async () => {
+    mockFetch.mockResolvedValueOnce({
+      ok: false,
+      status: 404,
+      text: async () => 'Change not found',
+    })
+
+    const response = await mockFetch('https://test.gerrit.com/a/changes/99999/abandon')
+    expect(response.ok).toBe(false)
+    expect(response.status).toBe(404)
+
+    const errorText = await response.text()
+    expect(errorText).toBe('Change not found')
+  })
+
+  it('should format message correctly in request body', () => {
+    const testCases = [
+      { input: undefined, expected: {} },
+      { input: '', expected: {} },
+      { input: 'Abandoning this change', expected: { message: 'Abandoning this change' } },
+      { input: 'Multi\nline\nmessage', expected: { message: 'Multi\nline\nmessage' } },
+    ]
+
+    for (const testCase of testCases) {
+      const body = testCase.input ? { message: testCase.input } : {}
+      expect(body).toEqual(testCase.expected)
+    }
+  })
+
+  describe('interactive mode API patterns', () => {
+    it('should fetch changes for interactive mode', async () => {
+      mockFetch.mockResolvedValueOnce({
+        ok: true,
+        text: async () => `)]}'\n[${JSON.stringify(mockChange)}]`,
+      })
+
+      // Test the API call pattern for interactive mode
+      const response = await mockFetch(
+        'https://test.gerrit.com/a/changes/?q=owner:self+status:open',
+      )
+      const text = await response.text()
+      expect(text).toContain('Test change to abandon')
+    })
+
+    it('should handle empty changes list response', async () => {
+      mockFetch.mockResolvedValueOnce({
+        ok: true,
+        text: async () => ")]}'\n[]",
+      })
+
+      const response = await mockFetch(
+        'https://test.gerrit.com/a/changes/?q=owner:self+status:open',
+      )
+      const text = await response.text()
+      const parsed = JSON.parse(text.replace(")]}'\n", ''))
+      expect(parsed).toEqual([])
+    })
+  })
+})

package/tests/ai-service.test.ts

@@ -0,0 +1,489 @@
+import { describe, test, expect, beforeEach, mock } from 'bun:test'
+import { Effect, Layer } from 'effect'
+import {
+  AiService,
+  AiServiceError,
+  NoAiToolFoundError,
+  AiResponseParseError,
+  AiServiceLive,
+} from '@/services/ai'
+import { ConfigService } from '@/services/config'
+import { createMockConfigService } from './helpers/config-mock'
+
+describe('AI Service', () => {
+  describe('extractResponseTag', () => {
+    test('should extract content from response tags', async () => {
+      const input = `Some text before
+<response>
+This is the response content
+</response>
+Some text after`
+
+      const result = await Effect.runPromise(
+        Effect.gen(function* () {
+          const service = yield* AiService
+          return yield* service.extractResponseTag(input)
+        }).pipe(
+          Effect.provide(
+            Layer.succeed(
+              AiService,
+              AiService.of({
+                detectAiTool: () =>
+                  Effect.fail(new NoAiToolFoundError({ message: 'Not implemented' })),
+                extractResponseTag: (output: string) =>
+                  Effect.gen(function* () {
+                    const responseMatch = output.match(/<response>([\s\S]*?)<\/response>/i)
+
+                    if (!responseMatch || !responseMatch[1]) {
+                      return yield* Effect.fail(
+                        new AiResponseParseError({
+                          message: 'No <response> tag found in AI output',
+                          rawOutput: output,
+                        }),
+                      )
+                    }
+
+                    return responseMatch[1].trim()
+                  }),
+                runPrompt: () => Effect.fail(new AiServiceError({ message: 'Not implemented' })),
+              }),
+            ),
+          ),
+        ),
+      )
+
+      expect(result).toBe('This is the response content')
+    })
+
+    test('should handle case-insensitive response tags', async () => {
+      const input = `<RESPONSE>Content here</RESPONSE>`
+
+      const result = await Effect.runPromise(
+        Effect.gen(function* () {
+          const service = yield* AiService
+          return yield* service.extractResponseTag(input)
+        }).pipe(
+          Effect.provide(
+            Layer.succeed(
+              AiService,
+              AiService.of({
+                detectAiTool: () =>
+                  Effect.fail(new NoAiToolFoundError({ message: 'Not implemented' })),
+                extractResponseTag: (output: string) =>
+                  Effect.gen(function* () {
+                    const responseMatch = output.match(/<response>([\s\S]*?)<\/response>/i)
+
+                    if (!responseMatch || !responseMatch[1]) {
+                      return yield* Effect.fail(
+                        new AiResponseParseError({
+                          message: 'No <response> tag found in AI output',
+                          rawOutput: output,
+                        }),
+                      )
+                    }
+
+                    return responseMatch[1].trim()
+                  }),
+                runPrompt: () => Effect.fail(new AiServiceError({ message: 'Not implemented' })),
+              }),
+            ),
+          ),
+        ),
+      )
+
+      expect(result).toBe('Content here')
+    })
+
+    test('should fail when no response tag is found', async () => {
+      const input = 'This is just plain text without tags'
+
+      const result = await Effect.runPromise(
+        Effect.either(
+          Effect.gen(function* () {
+            const service = yield* AiService
+            return yield* service.extractResponseTag(input)
+          }).pipe(
+            Effect.provide(
+              Layer.succeed(
+                AiService,
+                AiService.of({
+                  detectAiTool: () =>
+                    Effect.fail(new NoAiToolFoundError({ message: 'Not implemented' })),
+                  extractResponseTag: (output: string) =>
+                    Effect.gen(function* () {
+                      const responseMatch = output.match(/<response>([\s\S]*?)<\/response>/i)
+
+                      if (!responseMatch || !responseMatch[1]) {
+                        return yield* Effect.fail(
+                          new AiResponseParseError({
+                            message: 'No <response> tag found in AI output',
+                            rawOutput: output,
+                          }),
+                        )
+                      }
+
+                      return responseMatch[1].trim()
+                    }),
+                  runPrompt: () => Effect.fail(new AiServiceError({ message: 'Not implemented' })),
+                }),
+              ),
+            ),
+          ),
+        ),
+      )
+
+      expect(result._tag).toBe('Left')
+      if (result._tag === 'Left') {
+        expect(result.left).toBeInstanceOf(AiResponseParseError)
+        expect((result.left as AiResponseParseError).rawOutput).toBe(input)
+      }
+    })
+
+    test('should handle multiline content in response tags', async () => {
+      const input = `<response>
+Line 1
+Line 2
+Line 3
+</response>`
+
+      const result = await Effect.runPromise(
+        Effect.gen(function* () {
+          const service = yield* AiService
+          return yield* service.extractResponseTag(input)
+        }).pipe(
+          Effect.provide(
+            Layer.succeed(
+              AiService,
+              AiService.of({
+                detectAiTool: () =>
+                  Effect.fail(new NoAiToolFoundError({ message: 'Not implemented' })),
+                extractResponseTag: (output: string) =>
+                  Effect.gen(function* () {
+                    const responseMatch = output.match(/<response>([\s\S]*?)<\/response>/i)
+
+                    if (!responseMatch || !responseMatch[1]) {
+                      return yield* Effect.fail(
+                        new AiResponseParseError({
+                          message: 'No <response> tag found in AI output',
+                          rawOutput: output,
+                        }),
+                      )
+                    }
+
+                    return responseMatch[1].trim()
+                  }),
+                runPrompt: () => Effect.fail(new AiServiceError({ message: 'Not implemented' })),
+              }),
+            ),
+          ),
+        ),
+      )
+
+      expect(result).toBe('Line 1\nLine 2\nLine 3')
+    })
+  })
+
+  describe('Error Types', () => {
+    test('NoAiToolFoundError should have correct message', () => {
+      const error = new NoAiToolFoundError({
+        message: 'No AI tool found. Please install claude, llm, or opencode CLI.',
+      })
+      expect(error.message).toBe('No AI tool found. Please install claude, llm, or opencode CLI.')
+    })
+
+    test('AiResponseParseError should include raw output', () => {
+      const error = new AiResponseParseError({
+        message: 'Failed to parse response',
+        rawOutput: 'Some raw output',
+      })
+      expect(error.message).toBe('Failed to parse response')
+      expect(error.rawOutput).toBe('Some raw output')
+    })
+
+    test('AiServiceError should have message and optional cause', () => {
+      const cause = new Error('Original error')
+      const error = new AiServiceError({
+        message: 'Service failed',
+        cause,
+      })
+      expect(error.message).toBe('Service failed')
+      expect(error.cause).toBe(cause)
+    })
+  })
+
+  describe('detectAiTool', () => {
+    test('should detect claude tool when available', async () => {
+      // Mock which command to return success for claude
+      const mockExecAsync = mock(() =>
+        Promise.resolve({ stdout: '/usr/local/bin/claude\n', stderr: '' }),
+      )
+
+      const mockAiService = AiService.of({
+        detectAiTool: () => Effect.succeed('claude'),
+        extractResponseTag: (output: string) => Effect.succeed(output),
+        runPrompt: () => Effect.succeed('mock response'),
+      })
+
+      const result = await Effect.runPromise(
+        Effect.gen(function* () {
+          const service = yield* AiService
+          return yield* service.detectAiTool()
+        }).pipe(Effect.provide(Layer.succeed(AiService, mockAiService))),
+      )
+
+      expect(result).toBe('claude')
+    })
+
+    test('should detect llm tool when claude not available', async () => {
+      const mockAiService = AiService.of({
+        detectAiTool: () => Effect.succeed('llm'),
+        extractResponseTag: (output: string) => Effect.succeed(output),
+        runPrompt: () => Effect.succeed('mock response'),
+      })
+
+      const result = await Effect.runPromise(
+        Effect.gen(function* () {
+          const service = yield* AiService
+          return yield* service.detectAiTool()
+        }).pipe(Effect.provide(Layer.succeed(AiService, mockAiService))),
+      )
+
+      expect(result).toBe('llm')
+    })
+
+    test('should detect opencode tool when others not available', async () => {
+      const mockAiService = AiService.of({
+        detectAiTool: () => Effect.succeed('opencode'),
+        extractResponseTag: (output: string) => Effect.succeed(output),
+        runPrompt: () => Effect.succeed('mock response'),
+      })
+
+      const result = await Effect.runPromise(
+        Effect.gen(function* () {
+          const service = yield* AiService
+          return yield* service.detectAiTool()
+        }).pipe(Effect.provide(Layer.succeed(AiService, mockAiService))),
+      )
+
+      expect(result).toBe('opencode')
+    })
+
+    test('should detect gemini tool when others not available', async () => {
+      const mockAiService = AiService.of({
+        detectAiTool: () => Effect.succeed('gemini'),
+        extractResponseTag: (output: string) => Effect.succeed(output),
+        runPrompt: () => Effect.succeed('mock response'),
+      })
+
+      const result = await Effect.runPromise(
+        Effect.gen(function* () {
+          const service = yield* AiService
+          return yield* service.detectAiTool()
+        }).pipe(Effect.provide(Layer.succeed(AiService, mockAiService))),
+      )
+
+      expect(result).toBe('gemini')
+    })
+
+    test('should fail when no AI tools are available', async () => {
+      const mockAiService = AiService.of({
+        detectAiTool: () =>
+          Effect.fail(
+            new NoAiToolFoundError({
+              message: 'No AI tool found. Please install claude, llm, opencode, or gemini CLI.',
+            }),
+          ),
+        extractResponseTag: (output: string) => Effect.succeed(output),
+        runPrompt: () => Effect.succeed('mock response'),
+      })
+
+      const result = await Effect.runPromise(
+        Effect.either(
+          Effect.gen(function* () {
+            const service = yield* AiService
+            return yield* service.detectAiTool()
+          }).pipe(Effect.provide(Layer.succeed(AiService, mockAiService))),
+        ),
+      )
+
+      expect(result._tag).toBe('Left')
+      if (result._tag === 'Left') {
+        expect(result.left).toBeInstanceOf(NoAiToolFoundError)
+        expect((result.left as NoAiToolFoundError).message).toContain('No AI tool found')
+      }
+    })
+  })
+
+  describe('runPrompt', () => {
+    test('should successfully run prompt with claude', async () => {
+      const mockAiService = AiService.of({
+        detectAiTool: () => Effect.succeed('claude'),
+        extractResponseTag: (output: string) => Effect.succeed('extracted response'),
+        runPrompt: (prompt: string, input: string) => {
+          expect(prompt).toBe('Test prompt')
+          expect(input).toBe('Test input')
+          return Effect.succeed('extracted response')
+        },
+      })
+
+      const result = await Effect.runPromise(
+        Effect.gen(function* () {
+          const service = yield* AiService
+          return yield* service.runPrompt('Test prompt', 'Test input')
+        }).pipe(Effect.provide(Layer.succeed(AiService, mockAiService))),
+      )
+
+      expect(result).toBe('extracted response')
+    })
+
+    test('should successfully run prompt with llm', async () => {
+      const mockAiService = AiService.of({
+        detectAiTool: () => Effect.succeed('llm'),
+        extractResponseTag: (output: string) => Effect.succeed('llm response'),
+        runPrompt: (prompt: string, input: string) => {
+          return Effect.succeed('llm response')
+        },
+      })
+
+      const result = await Effect.runPromise(
+        Effect.gen(function* () {
+          const service = yield* AiService
+          return yield* service.runPrompt('Test prompt', 'Test input')
+        }).pipe(Effect.provide(Layer.succeed(AiService, mockAiService))),
+      )
+
+      expect(result).toBe('llm response')
+    })
+
+    test('should handle AI tool execution failure', async () => {
+      const mockAiService = AiService.of({
+        detectAiTool: () => Effect.succeed('claude'),
+        extractResponseTag: (output: string) => Effect.succeed(output),
+        runPrompt: () =>
+          Effect.fail(
+            new AiServiceError({
+              message: 'Failed to run AI tool: Command not found',
+              cause: new Error('ENOENT'),
+            }),
+          ),
+      })
+
+      const result = await Effect.runPromise(
+        Effect.either(
+          Effect.gen(function* () {
+            const service = yield* AiService
+            return yield* service.runPrompt('Test prompt', 'Test input')
+          }).pipe(Effect.provide(Layer.succeed(AiService, mockAiService))),
+        ),
+      )
+
+      expect(result._tag).toBe('Left')
+      if (result._tag === 'Left') {
+        expect(result.left).toBeInstanceOf(AiServiceError)
+        expect((result.left as AiServiceError).message).toContain('Failed to run AI tool')
+      }
+    })
+
+    test('should handle missing response tag in AI output', async () => {
+      const mockAiService = AiService.of({
+        detectAiTool: () => Effect.succeed('claude'),
+        extractResponseTag: (output: string) =>
+          Effect.fail(
+            new AiResponseParseError({
+              message: 'No <response> tag found in AI output',
+              rawOutput: 'Raw AI output without response tags',
+            }),
+          ),
+        runPrompt: () =>
+          Effect.fail(
+            new AiResponseParseError({
+              message: 'No <response> tag found in AI output',
+              rawOutput: 'Raw AI output without response tags',
+            }),
+          ),
+      })
+
+      const result = await Effect.runPromise(
+        Effect.either(
+          Effect.gen(function* () {
+            const service = yield* AiService
+            return yield* service.runPrompt('Test prompt', 'Test input')
+          }).pipe(Effect.provide(Layer.succeed(AiService, mockAiService))),
+        ),
+      )
+
+      expect(result._tag).toBe('Left')
+      if (result._tag === 'Left') {
+        expect(result.left).toBeInstanceOf(AiResponseParseError)
+        expect((result.left as AiResponseParseError).rawOutput).toBe(
+          'Raw AI output without response tags',
+        )
+      }
+    })
+
+    test('should handle no AI tool found during prompt execution', async () => {
+      const mockAiService = AiService.of({
+        detectAiTool: () =>
+          Effect.fail(
+            new NoAiToolFoundError({
+              message: 'No AI tool found',
+            }),
+          ),
+        extractResponseTag: (output: string) => Effect.succeed(output),
+        runPrompt: () =>
+          Effect.fail(
+            new NoAiToolFoundError({
+              message: 'No AI tool found',
+            }),
+          ),
+      })
+
+      const result = await Effect.runPromise(
+        Effect.either(
+          Effect.gen(function* () {
+            const service = yield* AiService
+            return yield* service.runPrompt('Test prompt', 'Test input')
+          }).pipe(Effect.provide(Layer.succeed(AiService, mockAiService))),
+        ),
+      )
+
+      expect(result._tag).toBe('Left')
+      if (result._tag === 'Left') {
+        expect(result.left).toBeInstanceOf(NoAiToolFoundError)
+      }
+    })
+
+    test('should format input correctly for AI tool', async () => {
+      const mockAiService = AiService.of({
+        detectAiTool: () => Effect.succeed('claude'),
+        extractResponseTag: (output: string) => Effect.succeed('response content'),
+        runPrompt: (prompt: string, input: string) => {
+          // Verify the prompt and input are passed correctly
+          expect(prompt).toBe('System: Analyze this code')
+          expect(input).toBe('function test() { return 42; }')
+          return Effect.succeed('response content')
+        },
+      })
+
+      const result = await Effect.runPromise(
+        Effect.gen(function* () {
+          const service = yield* AiService
+          return yield* service.runPrompt(
+            'System: Analyze this code',
+            'function test() { return 42; }',
+          )
+        }).pipe(Effect.provide(Layer.succeed(AiService, mockAiService))),
+      )
+
+      expect(result).toBe('response content')
+    })
+  })
+
+  describe('AiServiceLive integration', () => {
+    test('should be able to create live service layer', () => {
+      // Test that the live service layer can be created without errors
+      expect(AiServiceLive).toBeDefined()
+      expect(typeof AiServiceLive).toBe('object')
+    })
+  })
+})