@aaronshaf/ger 0.2.2 → 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.2",
+  "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/commands/show.ts

@@ -7,6 +7,7 @@ import { formatDiffPretty } from '@/utils/diff-formatters'
 import { sanitizeCDATA, escapeXML } from '@/utils/shell-safety'
 import { formatDate } from '@/utils/formatters'
 import { getChangeIdFromHead, GitError, NoChangeIdError } from '@/utils/git-commit'
+import { writeFileSync } from 'node:fs'
 
 interface ShowOptions {
   xml?: boolean
@@ -184,12 +185,12 @@ const removeUndefined = <T extends Record<string, any>>(obj: T): Partial<T> => {
   ) as Partial<T>
 }
 
-const formatShowJson = (
+const formatShowJson = async (
   changeDetails: ChangeDetails,
   diff: string,
   commentsWithContext: Array<{ comment: CommentInfo; context?: any }>,
   messages: MessageInfo[],
-): void => {
+): Promise<void> => {
   const output = {
     status: 'success',
     change: removeUndefined({
@@ -242,82 +243,118 @@ const formatShowJson = (
     ),
   }
 
-  console.log(JSON.stringify(output, null, 2))
+  const jsonOutput = JSON.stringify(output, null, 2) + '\n'
+  // Write to stdout and ensure all data is flushed before process exits
+  // Using process.stdout.write with drain handling for large payloads
+  return new Promise<void>((resolve, reject) => {
+    const written = process.stdout.write(jsonOutput, (err) => {
+      if (err) {
+        reject(err)
+      } else {
+        resolve()
+      }
+    })
+
+    if (!written) {
+      // If write returned false, buffer is full, wait for drain
+      process.stdout.once('drain', resolve)
+      process.stdout.once('error', reject)
+    }
+  })
 }
 
-const formatShowXml = (
+const formatShowXml = async (
   changeDetails: ChangeDetails,
   diff: string,
   commentsWithContext: Array<{ comment: CommentInfo; context?: any }>,
   messages: MessageInfo[],
-): void => {
-  console.log(`<?xml version="1.0" encoding="UTF-8"?>`)
-  console.log(`<show_result>`)
-  console.log(`  <status>success</status>`)
-  console.log(`  <change>`)
-  console.log(`    <id>${escapeXML(changeDetails.id)}</id>`)
-  console.log(`    <number>${changeDetails.number}</number>`)
-  console.log(`    <subject><![CDATA[${sanitizeCDATA(changeDetails.subject)}]]></subject>`)
-  console.log(`    <status>${escapeXML(changeDetails.status)}</status>`)
-  console.log(`    <project>${escapeXML(changeDetails.project)}</project>`)
-  console.log(`    <branch>${escapeXML(changeDetails.branch)}</branch>`)
-  console.log(`    <owner>`)
+): Promise<void> => {
+  // Build complete XML output as a single string to avoid multiple writes
+  const xmlParts: string[] = []
+  xmlParts.push(`<?xml version="1.0" encoding="UTF-8"?>`)
+  xmlParts.push(`<show_result>`)
+  xmlParts.push(`  <status>success</status>`)
+  xmlParts.push(`  <change>`)
+  xmlParts.push(`    <id>${escapeXML(changeDetails.id)}</id>`)
+  xmlParts.push(`    <number>${changeDetails.number}</number>`)
+  xmlParts.push(`    <subject><![CDATA[${sanitizeCDATA(changeDetails.subject)}]]></subject>`)
+  xmlParts.push(`    <status>${escapeXML(changeDetails.status)}</status>`)
+  xmlParts.push(`    <project>${escapeXML(changeDetails.project)}</project>`)
+  xmlParts.push(`    <branch>${escapeXML(changeDetails.branch)}</branch>`)
+  xmlParts.push(`    <owner>`)
   if (changeDetails.owner.name) {
-    console.log(`      <name><![CDATA[${sanitizeCDATA(changeDetails.owner.name)}]]></name>`)
+    xmlParts.push(`      <name><![CDATA[${sanitizeCDATA(changeDetails.owner.name)}]]></name>`)
   }
   if (changeDetails.owner.email) {
-    console.log(`      <email>${escapeXML(changeDetails.owner.email)}</email>`)
+    xmlParts.push(`      <email>${escapeXML(changeDetails.owner.email)}</email>`)
   }
-  console.log(`    </owner>`)
-  console.log(`    <created>${escapeXML(changeDetails.created || '')}</created>`)
-  console.log(`    <updated>${escapeXML(changeDetails.updated || '')}</updated>`)
-  console.log(`  </change>`)
-  console.log(`  <diff><![CDATA[${sanitizeCDATA(diff)}]]></diff>`)
+  xmlParts.push(`    </owner>`)
+  xmlParts.push(`    <created>${escapeXML(changeDetails.created || '')}</created>`)
+  xmlParts.push(`    <updated>${escapeXML(changeDetails.updated || '')}</updated>`)
+  xmlParts.push(`  </change>`)
+  xmlParts.push(`  <diff><![CDATA[${sanitizeCDATA(diff)}]]></diff>`)
 
   // Comments section
-  console.log(`  <comments>`)
-  console.log(`    <count>${commentsWithContext.length}</count>`)
+  xmlParts.push(`  <comments>`)
+  xmlParts.push(`    <count>${commentsWithContext.length}</count>`)
   for (const { comment } of commentsWithContext) {
-    console.log(`    <comment>`)
-    if (comment.id) console.log(`      <id>${escapeXML(comment.id)}</id>`)
-    if (comment.path) console.log(`      <path><![CDATA[${sanitizeCDATA(comment.path)}]]></path>`)
-    if (comment.line) console.log(`      <line>${comment.line}</line>`)
+    xmlParts.push(`    <comment>`)
+    if (comment.id) xmlParts.push(`      <id>${escapeXML(comment.id)}</id>`)
+    if (comment.path) xmlParts.push(`      <path><![CDATA[${sanitizeCDATA(comment.path)}]]></path>`)
+    if (comment.line) xmlParts.push(`      <line>${comment.line}</line>`)
     if (comment.author?.name) {
-      console.log(`      <author><![CDATA[${sanitizeCDATA(comment.author.name)}]]></author>`)
+      xmlParts.push(`      <author><![CDATA[${sanitizeCDATA(comment.author.name)}]]></author>`)
     }
-    if (comment.updated) console.log(`      <updated>${escapeXML(comment.updated)}</updated>`)
+    if (comment.updated) xmlParts.push(`      <updated>${escapeXML(comment.updated)}</updated>`)
     if (comment.message) {
-      console.log(`      <message><![CDATA[${sanitizeCDATA(comment.message)}]]></message>`)
+      xmlParts.push(`      <message><![CDATA[${sanitizeCDATA(comment.message)}]]></message>`)
     }
-    if (comment.unresolved) console.log(`      <unresolved>true</unresolved>`)
-    console.log(`    </comment>`)
+    if (comment.unresolved) xmlParts.push(`      <unresolved>true</unresolved>`)
+    xmlParts.push(`    </comment>`)
   }
-  console.log(`  </comments>`)
+  xmlParts.push(`  </comments>`)
 
   // Messages section
-  console.log(`  <messages>`)
-  console.log(`    <count>${messages.length}</count>`)
+  xmlParts.push(`  <messages>`)
+  xmlParts.push(`    <count>${messages.length}</count>`)
   for (const message of messages) {
-    console.log(`    <message>`)
-    console.log(`      <id>${escapeXML(message.id)}</id>`)
+    xmlParts.push(`    <message>`)
+    xmlParts.push(`      <id>${escapeXML(message.id)}</id>`)
     if (message.author?.name) {
-      console.log(`      <author><![CDATA[${sanitizeCDATA(message.author.name)}]]></author>`)
+      xmlParts.push(`      <author><![CDATA[${sanitizeCDATA(message.author.name)}]]></author>`)
     }
     if (message.author?._account_id) {
-      console.log(`      <author_id>${message.author._account_id}</author_id>`)
+      xmlParts.push(`      <author_id>${message.author._account_id}</author_id>`)
     }
-    console.log(`      <date>${escapeXML(message.date)}</date>`)
+    xmlParts.push(`      <date>${escapeXML(message.date)}</date>`)
     if (message._revision_number) {
-      console.log(`      <revision>${message._revision_number}</revision>`)
+      xmlParts.push(`      <revision>${message._revision_number}</revision>`)
     }
     if (message.tag) {
-      console.log(`      <tag>${escapeXML(message.tag)}</tag>`)
+      xmlParts.push(`      <tag>${escapeXML(message.tag)}</tag>`)
     }
-    console.log(`      <message><![CDATA[${sanitizeCDATA(message.message)}]]></message>`)
-    console.log(`    </message>`)
+    xmlParts.push(`      <message><![CDATA[${sanitizeCDATA(message.message)}]]></message>`)
+    xmlParts.push(`    </message>`)
   }
-  console.log(`  </messages>`)
-  console.log(`</show_result>`)
+  xmlParts.push(`  </messages>`)
+  xmlParts.push(`</show_result>`)
+
+  const xmlOutput = xmlParts.join('\n') + '\n'
+  // Write to stdout with proper drain handling for large payloads
+  return new Promise<void>((resolve, reject) => {
+    const written = process.stdout.write(xmlOutput, (err) => {
+      if (err) {
+        reject(err)
+      } else {
+        resolve()
+      }
+    })
+
+    if (!written) {
+      process.stdout.once('drain', resolve)
+      process.stdout.once('error', reject)
+    }
+  })
 }
 
 export const showCommand = (
@@ -358,9 +395,11 @@ export const showCommand = (
 
     // Format output
     if (options.json) {
-      formatShowJson(changeDetails, diff, commentsWithContext, messages)
+      yield* Effect.promise(() =>
+        formatShowJson(changeDetails, diff, commentsWithContext, messages),
+      )
     } else if (options.xml) {
-      formatShowXml(changeDetails, diff, commentsWithContext, messages)
+      yield* Effect.promise(() => formatShowXml(changeDetails, diff, commentsWithContext, messages))
     } else {
       formatShowPretty(changeDetails, diff, commentsWithContext, messages)
     }
@@ -373,22 +412,57 @@ export const showCommand = (
           : String(error)
 
       if (options.json) {
-        console.log(
-          JSON.stringify(
-            {
-              status: 'error',
-              error: errorMessage,
-            },
-            null,
-            2,
-          ),
+        return Effect.promise(
+          () =>
+            new Promise<void>((resolve, reject) => {
+              const errorOutput =
+                JSON.stringify(
+                  {
+                    status: 'error',
+                    error: errorMessage,
+                  },
+                  null,
+                  2,
+                ) + '\n'
+              const written = process.stdout.write(errorOutput, (err) => {
+                if (err) {
+                  reject(err)
+                } else {
+                  resolve()
+                }
+              })
+
+              if (!written) {
+                // Wait for drain if buffer is full
+                process.stdout.once('drain', resolve)
+                process.stdout.once('error', reject)
+              }
+            }),
         )
       } else if (options.xml) {
-        console.log(`<?xml version="1.0" encoding="UTF-8"?>`)
-        console.log(`<show_result>`)
-        console.log(`  <status>error</status>`)
-        console.log(`  <error><![CDATA[${sanitizeCDATA(errorMessage)}]]></error>`)
-        console.log(`</show_result>`)
+        return Effect.promise(
+          () =>
+            new Promise<void>((resolve, reject) => {
+              const xmlError =
+                `<?xml version="1.0" encoding="UTF-8"?>\n` +
+                `<show_result>\n` +
+                `  <status>error</status>\n` +
+                `  <error><![CDATA[${sanitizeCDATA(errorMessage)}]]></error>\n` +
+                `</show_result>\n`
+              const written = process.stdout.write(xmlError, (err) => {
+                if (err) {
+                  reject(err)
+                } else {
+                  resolve()
+                }
+              })
+
+              if (!written) {
+                process.stdout.once('drain', resolve)
+                process.stdout.once('error', reject)
+              }
+            }),
+        )
       } else {
         console.error(`✗ Error: ${errorMessage}`)
       }

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]')