@aaronshaf/ger 1.2.10 → 2.0.0

package/src/cli/commands/abandon.ts

@@ -0,0 +1,65 @@
+import { Effect } from 'effect'
+import { type ApiError, GerritApiService } from '@/api/gerrit'
+
+interface AbandonOptions {
+  message?: string
+  xml?: boolean
+}
+
+export const abandonCommand = (
+  changeId?: string,
+  options: AbandonOptions = {},
+): Effect.Effect<void, ApiError, GerritApiService> =>
+  Effect.gen(function* () {
+    const gerritApi = yield* GerritApiService
+
+    if (!changeId) {
+      console.error('✗ Change ID is required')
+      console.error('  Usage: ger abandon <change-id>')
+      return
+    }
+
+    try {
+      // First get the change details to show what we're abandoning
+      const change = yield* gerritApi.getChange(changeId)
+
+      // Perform the abandon
+      yield* gerritApi.abandonChange(changeId, options.message)
+
+      if (options.xml) {
+        console.log(`<?xml version="1.0" encoding="UTF-8"?>`)
+        console.log(`<abandon_result>`)
+        console.log(`  <status>success</status>`)
+        console.log(`  <change_number>${change._number}</change_number>`)
+        console.log(`  <subject><![CDATA[${change.subject}]]></subject>`)
+        if (options.message) {
+          console.log(`  <message><![CDATA[${options.message}]]></message>`)
+        }
+        console.log(`</abandon_result>`)
+      } else {
+        console.log(`✓ Abandoned change ${change._number}: ${change.subject}`)
+        if (options.message) {
+          console.log(`  Message: ${options.message}`)
+        }
+      }
+    } catch {
+      // If we can't get change details, still try to abandon with just the ID
+      yield* gerritApi.abandonChange(changeId, options.message)
+
+      if (options.xml) {
+        console.log(`<?xml version="1.0" encoding="UTF-8"?>`)
+        console.log(`<abandon_result>`)
+        console.log(`  <status>success</status>`)
+        console.log(`  <change_id>${changeId}</change_id>`)
+        if (options.message) {
+          console.log(`  <message><![CDATA[${options.message}]]></message>`)
+        }
+        console.log(`</abandon_result>`)
+      } else {
+        console.log(`✓ Abandoned change ${changeId}`)
+        if (options.message) {
+          console.log(`  Message: ${options.message}`)
+        }
+      }
+    }
+  })

package/src/cli/commands/add-reviewer.ts

@@ -0,0 +1,156 @@
+import { Effect } from 'effect'
+import { type ApiError, GerritApiService } from '@/api/gerrit'
+
+interface AddReviewerOptions {
+  change?: string
+  cc?: boolean
+  notify?: string
+  xml?: boolean
+  group?: boolean
+}
+
+type NotifyLevel = 'NONE' | 'OWNER' | 'OWNER_REVIEWERS' | 'ALL'
+
+const VALID_NOTIFY_LEVELS: ReadonlyArray<NotifyLevel> = ['NONE', 'OWNER', 'OWNER_REVIEWERS', 'ALL']
+
+const escapeXml = (str: string): string =>
+  str.replace(/&/g, '&amp;').replace(/</g, '&lt;').replace(/>/g, '&gt;').replace(/"/g, '&quot;')
+
+const outputXmlError = (message: string): void => {
+  console.log(`<?xml version="1.0" encoding="UTF-8"?>`)
+  console.log(`<add_reviewer_result>`)
+  console.log(`  <status>error</status>`)
+  console.log(`  <error><![CDATA[${message}]]></error>`)
+  console.log(`</add_reviewer_result>`)
+}
+
+class ValidationError extends Error {
+  readonly _tag = 'ValidationError'
+}
+
+export const addReviewerCommand = (
+  reviewers: string[],
+  options: AddReviewerOptions = {},
+): Effect.Effect<void, ApiError | ValidationError, GerritApiService> =>
+  Effect.gen(function* () {
+    const gerritApi = yield* GerritApiService
+
+    const changeId = options.change
+
+    if (!changeId) {
+      const message =
+        'Change ID is required. Use -c <change-id> or run from a branch with an active change.'
+      if (options.xml) {
+        outputXmlError(message)
+      } else {
+        console.error(`✗ ${message}`)
+      }
+      return yield* Effect.fail(new ValidationError(message))
+    }
+
+    if (reviewers.length === 0) {
+      const entityType = options.group ? 'group' : 'reviewer'
+      const message = `At least one ${entityType} is required.`
+      if (options.xml) {
+        outputXmlError(message)
+      } else {
+        console.error(`✗ ${message}`)
+      }
+      return yield* Effect.fail(new ValidationError(message))
+    }
+
+    // Validate that email-like inputs aren't used with --group flag
+    // Note: This uses a simple heuristic (presence of '@') to detect likely email addresses.
+    // While Gerrit group names could theoretically contain '@', this is rare in practice
+    // and the validation serves as a helpful UX guardrail against common mistakes.
+    if (options.group) {
+      const emailLikeInputs = reviewers.filter((r) => r.includes('@'))
+      if (emailLikeInputs.length > 0) {
+        const message = `The --group flag expects group identifiers, but received email-like input: ${emailLikeInputs.join(', ')}. Did you mean to omit --group?`
+        if (options.xml) {
+          outputXmlError(message)
+        } else {
+          console.error(`✗ ${message}`)
+        }
+        return yield* Effect.fail(new ValidationError(message))
+      }
+    }
+
+    const state: 'REVIEWER' | 'CC' = options.cc ? 'CC' : 'REVIEWER'
+    const entityType = options.group ? 'group' : 'individual'
+    const stateLabel = options.cc ? 'cc' : options.group ? 'group' : 'reviewer'
+
+    let notify: NotifyLevel | undefined
+    if (options.notify) {
+      const upperNotify = options.notify.toUpperCase()
+      if (!VALID_NOTIFY_LEVELS.includes(upperNotify as NotifyLevel)) {
+        const message = `Invalid notify level: ${options.notify}. Valid values: none, owner, owner_reviewers, all`
+        if (options.xml) {
+          outputXmlError(message)
+        } else {
+          console.error(`✗ ${message}`)
+        }
+        return yield* Effect.fail(new ValidationError(message))
+      }
+      notify = upperNotify as NotifyLevel
+    }
+
+    const results: Array<{ reviewer: string; success: boolean; name?: string; error?: string }> = []
+
+    for (const reviewer of reviewers) {
+      const result = yield* Effect.either(
+        gerritApi.addReviewer(changeId, reviewer, { state, notify }),
+      )
+
+      if (result._tag === 'Left') {
+        const error = result.left
+        const message = 'message' in error ? String(error.message) : String(error)
+        results.push({ reviewer, success: false, error: message })
+        continue
+      }
+
+      const apiResult = result.right
+
+      if (apiResult.error) {
+        results.push({ reviewer, success: false, error: apiResult.error })
+      } else {
+        const added = apiResult.reviewers?.[0] || apiResult.ccs?.[0]
+        const name = added?.name || added?.email || reviewer
+        results.push({ reviewer, success: true, name })
+      }
+    }
+
+    if (options.xml) {
+      console.log(`<?xml version="1.0" encoding="UTF-8"?>`)
+      console.log(`<add_reviewer_result>`)
+      console.log(`  <change_id>${escapeXml(changeId)}</change_id>`)
+      console.log(`  <state>${escapeXml(state)}</state>`)
+      console.log(`  <entity_type>${escapeXml(entityType)}</entity_type>`)
+      console.log(`  <reviewers>`)
+      for (const r of results) {
+        if (r.success) {
+          console.log(`    <reviewer status="added">`)
+          console.log(`      <input>${escapeXml(r.reviewer)}</input>`)
+          console.log(`      <name><![CDATA[${r.name}]]></name>`)
+          console.log(`    </reviewer>`)
+        } else {
+          console.log(`    <reviewer status="failed">`)
+          console.log(`      <input>${escapeXml(r.reviewer)}</input>`)
+          console.log(`      <error><![CDATA[${r.error}]]></error>`)
+          console.log(`    </reviewer>`)
+        }
+      }
+      console.log(`  </reviewers>`)
+      const allSuccess = results.every((r) => r.success)
+      console.log(`  <status>${allSuccess ? 'success' : 'partial_failure'}</status>`)
+      console.log(`</add_reviewer_result>`)
+    } else {
+      for (const r of results) {
+        if (r.success) {
+          console.log(`✓ Added ${r.name} as ${stateLabel}`)
+        } else {
+          console.error(`✗ Failed to add ${r.reviewer}: ${r.error}`)
+        }
+      }
+    }
+  })

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

@@ -0,0 +1,282 @@
+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'
+
+/** Help text for build-status command - exported to keep index.ts under line limit */
+export const BUILD_STATUS_HELP_TEXT = `
+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
+
+Exit codes:
+  - 0: Default for all states (like gh run watch)
+  - 1: Only when --exit-status is used AND build fails
+  - 2: Timeout reached in watch mode
+  - 3: API/network errors
+
+Examples:
+  # Single check (current behavior)
+  $ ger build-status 392385
+  {"state":"success"}
+
+  # Watch until completion (outputs JSON on each poll)
+  $ ger build-status 392385 --watch
+  {"state":"pending"}
+  {"state":"running"}
+  {"state":"running"}
+  {"state":"success"}
+
+  # Watch with custom interval (check every 5 seconds)
+  $ ger build-status --watch --interval 5
+
+  # Watch with custom timeout (60 minutes)
+  $ ger build-status --watch --timeout 3600
+
+  # Exit with code 1 on failure (for CI/CD pipelines)
+  $ ger build-status --watch --exit-status && deploy.sh
+
+  # Trigger notification when done (like gh run watch pattern)
+  $ ger build-status --watch && notify-send 'Build is done!'
+
+  # Parse final state in scripts
+  $ ger build-status --watch | tail -1 | jq -r '.state'
+  success
+
+Note: When no change-id is provided, it will be automatically extracted from the
+      Change-ID footer in your HEAD commit.`
+
+// Export types for external use
+export type BuildState = 'pending' | 'running' | 'success' | 'failure' | 'not_found'
+
+// Watch options (matches gh run watch pattern)
+export type WatchOptions = {
+  readonly watch: boolean
+  readonly interval: number // seconds
+  readonly timeout: number // seconds
+  readonly exitStatus: boolean
+}
+
+// Timeout error for watch mode
+export class TimeoutError extends Error {
+  readonly _tag = 'TimeoutError'
+  constructor(message: string) {
+    super(message)
+    this.name = 'TimeoutError'
+  }
+}
+
+// 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.
+ * Only considers verification messages for the same patchset as the latest build.
+ */
+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 and its revision number
+  let lastBuildDate: string | null = null
+  let lastBuildRevision: number | undefined = undefined
+  for (const msg of messages) {
+    if (BUILD_STARTED_PATTERN.test(msg.message)) {
+      lastBuildDate = msg.date
+      lastBuildRevision = msg._revision_number
+    }
+  }
+
+  // If no build has started, state is "pending"
+  if (!lastBuildDate) {
+    return { state: 'pending' }
+  }
+
+  // Check for verification messages after the build started AND for the same revision
+  for (const msg of messages) {
+    const date = msg.date
+    // Gerrit timestamps are ISO 8601 strings (lexicographically sortable)
+    if (date <= lastBuildDate) continue
+
+    // Only consider verification messages for the same patchset
+    // If revision numbers are available, they must match
+    if (lastBuildRevision !== undefined && msg._revision_number !== undefined) {
+      if (msg._revision_number !== lastBuildRevision) 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
+  })
+
+/**
+ * Poll build status until terminal state or timeout
+ * Outputs JSON status on each iteration (mimics gh run watch)
+ */
+const pollBuildStatus = (
+  changeId: string,
+  options: WatchOptions,
+): Effect.Effect<BuildStatus, ApiError | TimeoutError, GerritApiService> =>
+  Effect.gen(function* () {
+    const startTime = Date.now()
+    const timeoutMs = options.timeout * 1000
+
+    while (true) {
+      // Check timeout
+      const elapsed = Date.now() - startTime
+      if (elapsed > timeoutMs) {
+        yield* Effect.sync(() => {
+          console.error(`Timeout: Build status check exceeded ${options.timeout}s`)
+        })
+        yield* Effect.fail(
+          new TimeoutError(`Build status check timed out after ${options.timeout}s`),
+        )
+      }
+
+      // Fetch and parse status
+      const messages = yield* getMessagesForChange(changeId)
+      const status = parseBuildStatus(messages)
+
+      // Check timeout again after API call (in case it took longer than expected)
+      const elapsedAfterFetch = Date.now() - startTime
+      if (elapsedAfterFetch > timeoutMs) {
+        yield* Effect.sync(() => {
+          console.error(`Timeout: Build status check exceeded ${options.timeout}s`)
+        })
+        yield* Effect.fail(
+          new TimeoutError(`Build status check timed out after ${options.timeout}s`),
+        )
+      }
+
+      // Output current status to stdout (JSON, like single-check mode)
+      yield* Effect.sync(() => {
+        process.stdout.write(JSON.stringify(status) + '\n')
+      })
+
+      // Terminal states - wait for interval before returning to allow logs to be written
+      if (status.state === 'success' || status.state === 'not_found') {
+        return status
+      }
+
+      if (status.state === 'failure') {
+        // Wait for interval seconds to allow build failure logs to be fully written
+        yield* Effect.sleep(options.interval * 1000)
+        return status
+      }
+
+      // Non-terminal states - sleep for interval duration
+      yield* Effect.sleep(options.interval * 1000)
+    }
+  })
+
+/**
+ * Build status command with optional watch mode (mimics gh run watch)
+ */
+export const buildStatusCommand = (
+  changeId: string | undefined,
+  options: Partial<WatchOptions> = {},
+): Effect.Effect<
+  void,
+  ApiError | Error | GitError | NoChangeIdError | TimeoutError,
+  GerritApiService
+> =>
+  Effect.gen(function* () {
+    // Auto-detect Change-ID from HEAD commit if not provided
+    const resolvedChangeId = changeId || (yield* getChangeIdFromHead())
+
+    // Set defaults (matching gh run watch patterns)
+    const watchOpts: WatchOptions = {
+      watch: options.watch ?? false,
+      interval: Math.max(1, options.interval ?? 10), // Min 1 second
+      timeout: Math.max(1, options.timeout ?? 1800), // Min 1 second, default 30 minutes
+      exitStatus: options.exitStatus ?? false,
+    }
+
+    let status: BuildStatus
+
+    if (watchOpts.watch) {
+      // Polling mode - outputs JSON on each iteration
+      status = yield* pollBuildStatus(resolvedChangeId, watchOpts)
+    } else {
+      // Single check mode (existing behavior)
+      const messages = yield* getMessagesForChange(resolvedChangeId)
+      status = parseBuildStatus(messages)
+
+      // Output JSON to stdout
+      yield* Effect.sync(() => {
+        process.stdout.write(JSON.stringify(status) + '\n')
+      })
+    }
+
+    // Handle exit codes (only non-zero when explicitly requested)
+    if (watchOpts.exitStatus && status.state === 'failure') {
+      yield* Effect.sync(() => process.exit(1))
+    }
+
+    // Default: exit 0 for all states (success, failure, pending, etc.)
+  }).pipe(
+    Effect.catchAll((error) => {
+      // Timeout error
+      if (error instanceof TimeoutError) {
+        return Effect.sync(() => {
+          console.error(`Error: ${error.message}`)
+          process.exit(2)
+        })
+      }
+
+      // 404 - change not found
+      if (error && typeof error === 'object' && 'status' in error && error.status === 404) {
+        const status: BuildStatus = { state: 'not_found' }
+        return Effect.sync(() => {
+          process.stdout.write(JSON.stringify(status) + '\n')
+        })
+      }
+
+      // Other errors - exit 3
+      const errorMessage =
+        error instanceof GitError || error instanceof NoChangeIdError || error instanceof Error
+          ? error.message
+          : String(error)
+
+      return Effect.sync(() => {
+        console.error(`Error: ${errorMessage}`)
+        process.exit(3)
+      })
+    }),
+  )