@aaronshaf/ger 0.2.4 → 0.2.5

package/CLAUDE.md

@@ -25,10 +25,10 @@
 ### Testing & Coverage
 - **ENFORCE** minimum 80% code coverage
 - **RUN** all tests in pre-commit and pre-push hooks
-- **USE** Bun's native fetch mocking for all HTTP requests
+- **USE** MSW (Mock Service Worker) for all HTTP request mocking
 - **REQUIRE** meaningful integration tests for all commands that simulate full workflows
 - **IMPLEMENT** both unit tests and integration tests for every command modification/addition
-- **ENSURE** integration tests use realistic Bun HTTP mocks that match Gerrit API responses
+- **ENSURE** integration tests use realistic MSW handlers that match Gerrit API responses
 - **EXCLUDE** generated code and tmp/ from coverage
 
 ### Security
@@ -56,7 +56,7 @@
 ### Testing Requirements for Commands
 - **UNIT TESTS**: Test individual functions, schemas, and utilities
 - **INTEGRATION TESTS**: Test complete command flows with mocked HTTP requests
-- **HTTP MOCKING**: Use `global.fetch = mock(...)` pattern with Bun's native mocking
+- **HTTP MOCKING**: Use MSW handlers with http.get/http.post patterns for mocking
 - **SCHEMA VALIDATION**: Ensure mocks return data that validates against Effect Schemas
 - **COMMAND COVERAGE**: Every command must have integration tests covering:
   - Happy path execution

package/README.md

@@ -55,6 +55,10 @@ ger diff 12345
 # Extract URLs from messages (e.g., Jenkins build links)
 ger extract-url "build-summary-report" | tail -1
 
+# Check CI build status (parses build messages)
+ger build-status 12345  # Returns: pending, running, success, failure, or not_found
+ger build-status        # Auto-detects from HEAD commit
+
 # AI-powered code review (requires claude, llm, or opencode CLI)
 ger review 12345
 ger review 12345 --dry-run  # Preview without posting
@@ -249,6 +253,51 @@ ger extract-url "github.com" --include-comments
 ger extract-url "job/[^/]+/job/[^/]+/\d+/$" --regex
 ```
 
+### Build Status
+
+Check the CI build status of a change by parsing Gerrit messages for build events and verification results:
+
+```bash
+# Check build status for a specific change
+ger build-status 12345
+
+# Auto-detect change from HEAD commit
+ger build-status
+
+# Use in scripts with jq
+ger build-status | jq -r '.state'
+
+# Wait for build completion in CI scripts
+while [ "$(ger build-status | jq -r '.state')" = "running" ]; do
+  echo "Waiting for build..."
+  sleep 30
+done
+```
+
+#### Output format (JSON):
+```json
+{"state": "success"}
+```
+
+#### Build states:
+- **`pending`**: No "Build Started" message found yet
+- **`running`**: "Build Started" found, but no verification result yet
+- **`success`**: Verified +1 after most recent "Build Started"
+- **`failure`**: Verified -1 after most recent "Build Started"
+- **`not_found`**: Change does not exist
+
+#### How it works:
+1. Fetches all messages for the change
+2. Finds the most recent "Build Started" message
+3. Checks for "Verified +1" or "Verified -1" messages after the build started
+4. Returns the appropriate state
+
+#### Use cases:
+- **CI/CD integration**: Wait for builds before proceeding with deployment
+- **Automation**: Trigger actions based on build results
+- **Scripting**: Check build status in shell scripts
+- **Monitoring**: Poll build status for long-running builds
+
 ### Diff
 ```bash
 # Full diff

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@aaronshaf/ger",
-  "version": "0.2.4",
+  "version": "0.2.5",
   "description": "Gerrit CLI and SDK - A modern CLI tool and TypeScript SDK for Gerrit Code Review, built with Effect-TS",
   "keywords": [
     "gerrit",

package/src/cli/commands/build-status.ts

@@ -0,0 +1,116 @@
+import { Effect, Schema } from 'effect'
+import { type ApiError, GerritApiService } from '@/api/gerrit'
+import type { MessageInfo } from '@/schemas/gerrit'
+import { getChangeIdFromHead, GitError, NoChangeIdError } from '@/utils/git-commit'
+
+// Export types for external use
+export type BuildState = 'pending' | 'running' | 'success' | 'failure' | 'not_found'
+
+// Effect Schema for BuildStatus (follows project patterns)
+export const BuildStatus: Schema.Schema<{
+  readonly state: 'pending' | 'running' | 'success' | 'failure' | 'not_found'
+}> = Schema.Struct({
+  state: Schema.Literal('pending', 'running', 'success', 'failure', 'not_found'),
+})
+export type BuildStatus = Schema.Schema.Type<typeof BuildStatus>
+
+// Message patterns for precise matching
+const BUILD_STARTED_PATTERN = /Build\s+Started/i
+const VERIFIED_PLUS_PATTERN = /Verified\s*[+]\s*1/
+const VERIFIED_MINUS_PATTERN = /Verified\s*[-]\s*1/
+
+/**
+ * Parse messages to determine build status based on "Build Started" and verification messages
+ */
+const parseBuildStatus = (messages: readonly MessageInfo[]): BuildStatus => {
+  // Empty messages means change exists but has no activity yet - return pending
+  if (messages.length === 0) {
+    return { state: 'pending' }
+  }
+
+  // Find the most recent "Build Started" message
+  let lastBuildDate: string | null = null
+  for (const msg of messages) {
+    if (BUILD_STARTED_PATTERN.test(msg.message)) {
+      lastBuildDate = msg.date
+    }
+  }
+
+  // If no build has started, state is "pending"
+  if (!lastBuildDate) {
+    return { state: 'pending' }
+  }
+
+  // Check for verification messages after the build started
+  for (const msg of messages) {
+    const date = msg.date
+    // Gerrit timestamps are ISO 8601 strings (lexicographically sortable)
+    if (date <= lastBuildDate) continue
+
+    if (VERIFIED_PLUS_PATTERN.test(msg.message)) {
+      return { state: 'success' }
+    } else if (VERIFIED_MINUS_PATTERN.test(msg.message)) {
+      return { state: 'failure' }
+    }
+  }
+
+  // Build started but no verification yet, state is "running"
+  return { state: 'running' }
+}
+
+/**
+ * Get messages for a change
+ */
+const getMessagesForChange = (
+  changeId: string,
+): Effect.Effect<readonly MessageInfo[], ApiError, GerritApiService> =>
+  Effect.gen(function* () {
+    const gerritApi = yield* GerritApiService
+    const messages = yield* gerritApi.getMessages(changeId)
+    return messages
+  })
+
+/**
+ * Build status command - determines build status from Gerrit messages
+ */
+export const buildStatusCommand = (
+  changeId: string | undefined,
+): Effect.Effect<void, ApiError | Error | GitError | NoChangeIdError, GerritApiService> =>
+  Effect.gen(function* () {
+    // Auto-detect Change-ID from HEAD commit if not provided
+    const resolvedChangeId = changeId || (yield* getChangeIdFromHead())
+
+    // Fetch messages
+    const messages = yield* getMessagesForChange(resolvedChangeId)
+
+    // Parse build status
+    const status = parseBuildStatus(messages)
+
+    // Output JSON to stdout
+    const jsonOutput = JSON.stringify(status) + '\n'
+    yield* Effect.sync(() => {
+      process.stdout.write(jsonOutput)
+    })
+  }).pipe(
+    // Error handling - return not_found for API errors (e.g., change not found)
+    Effect.catchAll((error) => {
+      if (error && typeof error === 'object' && 'status' in error && error.status === 404) {
+        // Change not found - output not_found state and exit successfully
+        const status: BuildStatus = { state: 'not_found' }
+        return Effect.sync(() => {
+          process.stdout.write(JSON.stringify(status) + '\n')
+        })
+      }
+
+      // For other errors, write to stderr and exit with error
+      const errorMessage =
+        error instanceof GitError || error instanceof NoChangeIdError || error instanceof Error
+          ? error.message
+          : String(error)
+
+      return Effect.sync(() => {
+        console.error(`Error: ${errorMessage}`)
+        process.exit(1)
+      })
+    }),
+  )

package/src/cli/index.ts

@@ -31,6 +31,7 @@ import { ConfigServiceLive } from '@/services/config'
 import { ReviewStrategyServiceLive } from '@/services/review-strategy'
 import { GitWorktreeServiceLive } from '@/services/git-worktree'
 import { abandonCommand } from './commands/abandon'
+import { buildStatusCommand } from './commands/build-status'
 import { commentCommand } from './commands/comment'
 import { commentsCommand } from './commands/comments'
 import { diffCommand } from './commands/diff'
@@ -419,6 +420,63 @@ Note: When no change-id is provided, it will be automatically extracted from the
     }
   })
 
+// build-status command
+program
+  .command('build-status [change-id]')
+  .description(
+    'Check build status from Gerrit messages (auto-detects from HEAD commit if not specified)',
+  )
+  .addHelpText(
+    'after',
+    `
+This command parses Gerrit change messages to determine build status.
+It looks for "Build Started" messages and subsequent verification labels.
+
+Output is JSON with a "state" field that can be:
+  - pending: No build has started yet
+  - running: Build started but no verification yet
+  - success: Build completed with Verified+1
+  - failure: Build completed with Verified-1
+  - not_found: Change does not exist
+
+Examples:
+  # Check build status for specific change (using change number)
+  $ ger build-status 392385
+  {"state":"success"}
+
+  # Check build status for specific change (using Change-ID)
+  $ ger build-status If5a3ae8cb5a107e187447802358417f311d0c4b1
+  {"state":"running"}
+
+  # Auto-detect from HEAD commit
+  $ ger build-status
+  {"state":"pending"}
+
+  # Use in scripts (exit code 0 on success, 1 on error)
+  $ if ger build-status | jq -e '.state == "success"' > /dev/null; then
+      echo "Build passed!"
+    fi
+
+Note: When no change-id is provided, it will be automatically extracted from the
+      Change-ID footer in your HEAD commit.`,
+  )
+  .action(async (changeId) => {
+    try {
+      const effect = buildStatusCommand(changeId).pipe(
+        Effect.provide(GerritApiServiceLive),
+        Effect.provide(ConfigServiceLive),
+      )
+      await Effect.runPromise(effect)
+    } catch (error) {
+      // Errors are handled within the command itself
+      // This catch is just for any unexpected errors
+      if (error instanceof Error && error.message !== 'Process exited') {
+        console.error('✗ Unexpected error:', error.message)
+        process.exit(1)
+      }
+    }
+  })
+
 // extract-url command
 program
   .command('extract-url <pattern> [change-id]')

package/tests/abandon.test.ts

@@ -1,4 +1,11 @@
-import { beforeEach, describe, expect, it, mock } from 'bun:test'
+import { afterAll, afterEach, beforeAll, beforeEach, describe, expect, it, mock } from 'bun:test'
+import { Effect, Layer } from 'effect'
+import { HttpResponse, http } from 'msw'
+import { setupServer } from 'msw/node'
+import { GerritApiServiceLive } from '@/api/gerrit'
+import { abandonCommand } from '@/cli/commands/abandon'
+import { ConfigService } from '@/services/config'
+import { createMockConfigService } from './helpers/config-mock'
 import type { ChangeInfo } from '@/schemas/gerrit'
 
 const mockChange: ChangeInfo = {
@@ -28,136 +35,196 @@ const mockChange: ChangeInfo = {
   submittable: false,
 }
 
+// Create MSW server
+const server = setupServer(
+  // Default handler for auth check
+  http.get('*/a/accounts/self', ({ request }) => {
+    const auth = request.headers.get('Authorization')
+    if (!auth || !auth.startsWith('Basic ')) {
+      return HttpResponse.text('Unauthorized', { status: 401 })
+    }
+    return HttpResponse.json({
+      _account_id: 1000,
+      name: 'Test User',
+      email: 'test@example.com',
+    })
+  }),
+)
+
 describe('abandon command', () => {
-  let mockFetch: ReturnType<typeof mock>
+  let mockConsoleLog: ReturnType<typeof mock>
+  let mockConsoleError: ReturnType<typeof mock>
+
+  beforeAll(() => {
+    server.listen({ onUnhandledRequest: 'bypass' })
+  })
+
+  afterAll(() => {
+    server.close()
+  })
 
   beforeEach(() => {
-    // Reset fetch mock for each test
-    mockFetch = mock(() =>
-      Promise.resolve({
-        ok: true,
-        status: 200,
-        text: () => Promise.resolve(')]}\n{}'),
+    mockConsoleLog = mock(() => {})
+    mockConsoleError = mock(() => {})
+    console.log = mockConsoleLog
+    console.error = mockConsoleError
+  })
+
+  afterEach(() => {
+    server.resetHandlers()
+  })
+
+  it('should abandon a change with a message', async () => {
+    server.use(
+      http.get('*/a/changes/12345', () => {
+        return HttpResponse.text(`)]}'\n${JSON.stringify(mockChange)}`)
+      }),
+      http.post('*/a/changes/12345/abandon', async ({ request }) => {
+        const body = (await request.json()) as { message?: string }
+        expect(body.message).toBe('No longer needed')
+        return HttpResponse.text(")]}'\n{}")
       }),
     )
-    global.fetch = mockFetch as unknown as typeof fetch
+
+    const mockConfigLayer = Layer.succeed(ConfigService, createMockConfigService())
+    const program = abandonCommand('12345', {
+      message: 'No longer needed',
+    }).pipe(Effect.provide(GerritApiServiceLive), Effect.provide(mockConfigLayer))
+
+    await Effect.runPromise(program)
+
+    const output = mockConsoleLog.mock.calls.map((call) => call[0]).join('\n')
+    expect(output).toContain('Abandoned change 12345')
+    expect(output).toContain('Test change to abandon')
+    expect(output).toContain('Message: No longer needed')
   })
 
-  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)
+  it('should abandon a change without a message', async () => {
+    server.use(
+      http.get('*/a/changes/12345', () => {
+        return HttpResponse.text(`)]}'\n${JSON.stringify(mockChange)}`)
+      }),
+      http.post('*/a/changes/12345/abandon', async ({ request }) => {
+        const body = (await request.json()) as { message?: string }
+        expect(body.message).toBeUndefined()
+        return HttpResponse.text(")]}'\n{}")
+      }),
+    )
 
-    // Verify calls were made
-    expect(mockFetch).toHaveBeenCalledTimes(2)
+    const mockConfigLayer = Layer.succeed(ConfigService, createMockConfigService())
+    const program = abandonCommand('12345', {}).pipe(
+      Effect.provide(GerritApiServiceLive),
+      Effect.provide(mockConfigLayer),
+    )
+
+    await Effect.runPromise(program)
+
+    const output = mockConsoleLog.mock.calls.map((call) => call[0]).join('\n')
+    expect(output).toContain('Abandoned change 12345')
+    expect(output).toContain('Test change to abandon')
+    expect(output).not.toContain('Message:')
   })
 
-  it('should handle abandon without message', async () => {
-    mockFetch.mockResolvedValueOnce({
-      ok: true,
-      text: async () => ')]}\n{}',
-    })
+  it('should output XML format when --xml flag is used', async () => {
+    server.use(
+      http.get('*/a/changes/12345', () => {
+        return HttpResponse.text(`)]}'\n${JSON.stringify(mockChange)}`)
+      }),
+      http.post('*/a/changes/12345/abandon', async ({ request }) => {
+        const body = (await request.json()) as { message?: string }
+        expect(body.message).toBe('Abandoning for testing')
+        return HttpResponse.text(")]}'\n{}")
+      }),
+    )
 
-    const response = await mockFetch('https://test.gerrit.com/a/changes/12345/abandon', {
-      method: 'POST',
-      body: JSON.stringify({}),
-    })
+    const mockConfigLayer = Layer.succeed(ConfigService, createMockConfigService())
+    const program = abandonCommand('12345', {
+      xml: true,
+      message: 'Abandoning for testing',
+    }).pipe(Effect.provide(GerritApiServiceLive), Effect.provide(mockConfigLayer))
+
+    await Effect.runPromise(program)
+
+    const output = mockConsoleLog.mock.calls.map((call) => call[0]).join('\n')
+    expect(output).toContain('<?xml version="1.0" encoding="UTF-8"?>')
+    expect(output).toContain('<abandon_result>')
+    expect(output).toContain('<status>success</status>')
+    expect(output).toContain('<change_number>12345</change_number>')
+    expect(output).toContain('<subject><![CDATA[Test change to abandon]]></subject>')
+    expect(output).toContain('<message><![CDATA[Abandoning for testing]]></message>')
+    expect(output).toContain('</abandon_result>')
+  })
 
-    expect(response.ok).toBe(true)
-    expect(mockFetch).toHaveBeenCalledWith('https://test.gerrit.com/a/changes/12345/abandon', {
-      method: 'POST',
-      body: JSON.stringify({}),
-    })
+  it('should output XML format without message when no message provided', async () => {
+    server.use(
+      http.get('*/a/changes/12345', () => {
+        return HttpResponse.text(`)]}'\n${JSON.stringify(mockChange)}`)
+      }),
+      http.post('*/a/changes/12345/abandon', async () => {
+        return HttpResponse.text(")]}'\n{}")
+      }),
+    )
+
+    const mockConfigLayer = Layer.succeed(ConfigService, createMockConfigService())
+    const program = abandonCommand('12345', { xml: true }).pipe(
+      Effect.provide(GerritApiServiceLive),
+      Effect.provide(mockConfigLayer),
+    )
+
+    await Effect.runPromise(program)
+
+    const output = mockConsoleLog.mock.calls.map((call) => call[0]).join('\n')
+    expect(output).toContain('<abandon_result>')
+    expect(output).toContain('<status>success</status>')
+    expect(output).not.toContain('<message>')
   })
 
-  it('should handle API errors', async () => {
-    mockFetch.mockResolvedValueOnce({
-      ok: false,
-      status: 404,
-      text: async () => 'Change not found',
-    })
+  it('should handle not found errors gracefully', async () => {
+    server.use(
+      http.get('*/a/changes/99999', () => {
+        return HttpResponse.text('Change not found', { status: 404 })
+      }),
+    )
 
-    const response = await mockFetch('https://test.gerrit.com/a/changes/99999/abandon')
-    expect(response.ok).toBe(false)
-    expect(response.status).toBe(404)
+    const mockConfigLayer = Layer.succeed(ConfigService, createMockConfigService())
+    const program = abandonCommand('99999', {
+      message: 'Test message',
+    }).pipe(Effect.provide(GerritApiServiceLive), Effect.provide(mockConfigLayer))
 
-    const errorText = await response.text()
-    expect(errorText).toBe('Change not found')
+    // Should fail when change is not found
+    await expect(Effect.runPromise(program)).rejects.toThrow()
   })
 
-  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)
-    }
+  it('should show error when change ID is not provided', async () => {
+    const mockConfigLayer = Layer.succeed(ConfigService, createMockConfigService())
+    const program = abandonCommand(undefined, {}).pipe(
+      Effect.provide(GerritApiServiceLive),
+      Effect.provide(mockConfigLayer),
+    )
+
+    await Effect.runPromise(program)
+
+    const errorOutput = mockConsoleError.mock.calls.map((call) => call[0]).join('\n')
+    expect(errorOutput).toContain('Change ID is required')
+    expect(errorOutput).toContain('Usage: ger abandon <change-id>')
   })
 
-  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 abandon API failure', async () => {
+    server.use(
+      http.get('*/a/changes/12345', () => {
+        return HttpResponse.text(`)]}'\n${JSON.stringify(mockChange)}`)
+      }),
+      http.post('*/a/changes/12345/abandon', () => {
+        return HttpResponse.text('Forbidden', { status: 403 })
+      }),
+    )
 
-    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([])
-    })
+    const mockConfigLayer = Layer.succeed(ConfigService, createMockConfigService())
+    const program = abandonCommand('12345', {
+      message: 'Test',
+    }).pipe(Effect.provide(GerritApiServiceLive), Effect.provide(mockConfigLayer))
+
+    // Should throw/fail
+    await expect(Effect.runPromise(program)).rejects.toThrow()
   })
 })