@aaronshaf/ger 3.0.2 → 4.0.1

package/src/cli/commands/cherry.ts

@@ -0,0 +1,268 @@
+import { execSync, spawnSync } from 'node:child_process'
+import { Console, Effect, Schema } from 'effect'
+import chalk from 'chalk'
+import { ConfigService, type ConfigError, type ConfigServiceImpl } from '@/services/config'
+import { GerritApiService, type ApiError, type GerritApiServiceImpl } from '@/api/gerrit'
+import { extractChangeNumber } from '@/utils/url-parser'
+
+export const CHERRY_HELP_TEXT = `
+Examples:
+  # Cherry-pick latest patchset
+  $ ger cherry 12345
+
+  # Cherry-pick a specific patchset
+  $ ger cherry 12345/3
+
+  # Cherry-pick by Change-ID
+  $ ger cherry If5a3ae8cb5a107e187447802358417f311d0c4b1
+
+  # Cherry-pick from URL
+  $ ger cherry https://gerrit.example.com/c/my-project/+/12345
+
+  # Stage changes without committing
+  $ ger cherry 12345 --no-commit
+
+  # Use a specific remote
+  $ ger cherry 12345 --remote upstream
+
+Notes:
+  - Fetches the change then runs git cherry-pick FETCH_HEAD
+  - Use --no-commit to stage without committing (git cherry-pick -n)`
+
+export interface CherryOptions {
+  noCommit?: boolean
+  remote?: string
+  noVerify?: boolean
+}
+
+class CherryError extends Error {
+  readonly _tag = 'CherryError' as const
+  constructor(message: string) {
+    super(message)
+    this.name = 'CherryError'
+  }
+}
+
+class NotGitRepoError extends Error {
+  readonly _tag = 'NotGitRepoError' as const
+  constructor(message: string) {
+    super(message)
+    this.name = 'NotGitRepoError'
+  }
+}
+
+class PatchsetNotFoundError extends Error {
+  readonly _tag = 'PatchsetNotFoundError' as const
+  constructor(public readonly patchset: number) {
+    super(`Patchset ${patchset} not found`)
+    this.name = 'PatchsetNotFoundError'
+  }
+}
+
+class InvalidInputError extends Error {
+  readonly _tag = 'InvalidInputError' as const
+  constructor(message: string) {
+    super(message)
+    this.name = 'InvalidInputError'
+  }
+}
+
+export type CherryErrors =
+  | ConfigError
+  | ApiError
+  | CherryError
+  | NotGitRepoError
+  | PatchsetNotFoundError
+  | InvalidInputError
+
+// Git-safe string validation — prevents command injection
+const GitSafeString = Schema.String.pipe(
+  Schema.pattern(/^[a-zA-Z0-9_\-/.]+$/),
+  Schema.annotations({ message: () => 'Invalid characters in git identifier' }),
+)
+
+// Gerrit ref validation (refs/changes/xx/xxxxx/x)
+const GerritRef = Schema.String.pipe(
+  Schema.pattern(/^refs\/changes\/\d{2}\/\d+\/\d+$/),
+  Schema.annotations({ message: () => 'Invalid Gerrit ref format' }),
+)
+
+const validateGitSafe = (
+  value: string,
+  fieldName: string,
+): Effect.Effect<string, InvalidInputError> =>
+  Schema.decodeUnknown(GitSafeString)(value).pipe(
+    Effect.mapError(() => {
+      const sanitized = value.length > 20 ? `${value.substring(0, 20)}...` : value
+      return new InvalidInputError(`${fieldName} contains invalid characters: ${sanitized}`)
+    }),
+  )
+
+const validateGerritRef = (value: string): Effect.Effect<string, InvalidInputError> =>
+  Schema.decodeUnknown(GerritRef)(value).pipe(
+    Effect.mapError(() => {
+      const sanitized = value.length > 30 ? `${value.substring(0, 30)}...` : value
+      return new InvalidInputError(`Invalid Gerrit ref format: ${sanitized}`)
+    }),
+  )
+
+interface ParsedChange {
+  changeId: string
+  patchset?: number
+}
+
+const parseChangeInput = (input: string): ParsedChange => {
+  const trimmed = input.trim()
+
+  if (trimmed.startsWith('http://') || trimmed.startsWith('https://')) {
+    const changeId = extractChangeNumber(trimmed)
+    const patchsetMatch = trimmed.match(/\/\d+\/(\d+)(?:\/|$)/)
+    if (patchsetMatch?.[1]) {
+      return { changeId, patchset: parseInt(patchsetMatch[1], 10) }
+    }
+    return { changeId }
+  }
+
+  if (trimmed.includes('/') && !trimmed.startsWith('http')) {
+    const parts = trimmed.split('/')
+    if (parts.length === 2) {
+      const [changeId, patchsetStr] = parts
+      const patchset = parseInt(patchsetStr, 10)
+      if (!Number.isNaN(patchset) && patchset > 0) {
+        return { changeId, patchset }
+      }
+      return { changeId }
+    }
+  }
+
+  return { changeId: trimmed }
+}
+
+const getGitRemotes = (): Record<string, string> => {
+  try {
+    const output = execSync('git remote -v', { encoding: 'utf8', timeout: 5000 })
+    const remotes: Record<string, string> = {}
+    for (const line of output.split('\n')) {
+      const match = line.match(/^(\S+)\s+(\S+)\s+\(fetch\)$/)
+      if (match) remotes[match[1]] = match[2]
+    }
+    return remotes
+  } catch {
+    return {}
+  }
+}
+
+const findMatchingRemote = (gerritHost: string): string | null => {
+  const remotes = getGitRemotes()
+  const gerritHostname = new URL(gerritHost).hostname
+  for (const [name, url] of Object.entries(remotes)) {
+    try {
+      let remoteHostname: string
+      if (url.startsWith('git@')) {
+        remoteHostname = url.split('@')[1].split(':')[0]
+      } else if (url.includes('://')) {
+        remoteHostname = new URL(url).hostname
+      } else {
+        continue
+      }
+      if (remoteHostname === gerritHostname) return name
+    } catch {
+      // ignore malformed URLs
+    }
+  }
+  return null
+}
+
+const isInGitRepo = (): boolean => {
+  try {
+    execSync('git rev-parse --git-dir', { encoding: 'utf8', timeout: 5000 })
+    return true
+  } catch {
+    return false
+  }
+}
+
+export const cherryCommand = (
+  changeInput: string,
+  options: CherryOptions,
+): Effect.Effect<void, CherryErrors, ConfigServiceImpl | GerritApiServiceImpl> =>
+  Effect.gen(function* () {
+    const parsed = parseChangeInput(changeInput)
+
+    if (!isInGitRepo()) {
+      return yield* Effect.fail(new NotGitRepoError('Not in a git repository'))
+    }
+
+    const configService = yield* ConfigService
+    const apiService = yield* GerritApiService
+    const credentials = yield* configService.getCredentials
+
+    const change = yield* apiService.getChange(parsed.changeId)
+
+    const revision = yield* Effect.gen(function* () {
+      if (parsed.patchset !== undefined) {
+        const patchsetNum = parsed.patchset
+        return yield* apiService
+          .getRevision(parsed.changeId, patchsetNum.toString())
+          .pipe(Effect.catchAll(() => Effect.fail(new PatchsetNotFoundError(patchsetNum))))
+      }
+
+      if (change.current_revision && change.revisions) {
+        const currentRevision = change.revisions[change.current_revision]
+        if (currentRevision) return currentRevision
+      }
+
+      return yield* apiService.getRevision(parsed.changeId, 'current')
+    })
+
+    const validatedRef = yield* validateGerritRef(revision.ref)
+    const rawRemote = options.remote ?? findMatchingRemote(credentials.host) ?? 'origin'
+    const remote = yield* validateGitSafe(rawRemote, 'remote')
+
+    yield* Console.log(chalk.bold('Cherry-picking Gerrit change'))
+    yield* Console.log(`  Change:   ${chalk.cyan(String(change._number))} — ${change.subject}`)
+    yield* Console.log(`  Patchset: ${revision._number}`)
+    yield* Console.log(`  Branch:   ${change.branch}`)
+    yield* Console.log(`  Remote:   ${remote}`)
+    yield* Console.log('')
+
+    yield* Console.log(chalk.dim(`Fetching ${validatedRef}...`))
+    yield* Effect.try({
+      try: () => {
+        const result = spawnSync('git', ['fetch', remote, validatedRef], {
+          stdio: 'inherit',
+          timeout: 60000,
+        })
+        if (result.status !== 0) throw new Error(result.stderr?.toString() ?? 'fetch failed')
+      },
+      catch: (e) =>
+        new CherryError(`Failed to fetch: ${e instanceof Error ? e.message : String(e)}`),
+    })
+
+    const cherryPickCmd = [
+      'cherry-pick',
+      ...(options.noCommit ? ['-n'] : []),
+      ...(options.noVerify ? ['--no-verify'] : []),
+      'FETCH_HEAD',
+    ]
+    yield* Console.log(
+      chalk.dim(`Running git cherry-pick ${options.noCommit ? '-n ' : ''}FETCH_HEAD...`),
+    )
+    yield* Effect.try({
+      try: () => {
+        const result = spawnSync('git', cherryPickCmd, { stdio: 'inherit', timeout: 60000 })
+        if (result.status !== 0) throw new Error(result.stderr?.toString() ?? 'cherry-pick failed')
+      },
+      catch: (e) =>
+        new CherryError(`Cherry-pick failed: ${e instanceof Error ? e.message : String(e)}`),
+    })
+
+    yield* Console.log('')
+    if (options.noCommit) {
+      yield* Console.log(
+        chalk.green('✓ Changes staged (not committed). Review then run git commit.'),
+      )
+    } else {
+      yield* Console.log(chalk.green(`✓ Cherry-picked change ${change._number} successfully`))
+    }
+  })

package/src/cli/commands/failures.ts

@@ -0,0 +1,74 @@
+import { Console, Effect } from 'effect'
+import type { MessageInfo } from '@/schemas/gerrit'
+import { ConfigService, type ConfigError, type ConfigServiceImpl } from '@/services/config'
+import { GerritApiService, type ApiError, type GerritApiServiceImpl } from '@/api/gerrit'
+
+export interface FailuresOptions {
+  json?: boolean
+  xml?: boolean
+}
+
+export type FailuresErrors = ConfigError | ApiError
+
+const JENKINS_LINK_RE =
+  /https:\/\/jenkins\.inst-ci\.net\/job\/Canvas\/job\/[^/]+\/\d+\/\/build-summary-report\//
+
+const isServiceCloudJenkins = (msg: MessageInfo): boolean => {
+  const author = msg.author
+  if (!author) return false
+  const name = (author.name ?? author.username ?? author.email ?? '').toLowerCase()
+  return name.includes('service cloud jenkins')
+}
+
+const findMostRecentFailureLink = (messages: readonly MessageInfo[]): string | null => {
+  for (let i = messages.length - 1; i >= 0; i--) {
+    const msg = messages[i]
+    if (!isServiceCloudJenkins(msg)) continue
+    if (!msg.message.includes('Verified-1')) continue
+    const match = JENKINS_LINK_RE.exec(msg.message)
+    if (match) return match[0]
+  }
+  return null
+}
+
+export const failuresCommand = (
+  changeId: string,
+  options: FailuresOptions,
+): Effect.Effect<void, FailuresErrors, ConfigServiceImpl | GerritApiServiceImpl> =>
+  Effect.gen(function* () {
+    const _config = yield* ConfigService
+    const api = yield* GerritApiService
+
+    const messages = yield* api.getMessages(changeId)
+    const link = findMostRecentFailureLink(messages)
+
+    if (!link) {
+      if (options.json) {
+        yield* Console.log(JSON.stringify({ status: 'not_found', change_id: changeId }, null, 2))
+      } else if (options.xml) {
+        yield* Console.log(`<?xml version="1.0" encoding="UTF-8"?>`)
+        yield* Console.log(`<failures>`)
+        yield* Console.log(`  <status>not_found</status>`)
+        yield* Console.log(`  <change_id>${changeId}</change_id>`)
+        yield* Console.log(`</failures>`)
+      } else {
+        yield* Console.log('No build failure links found from Service Cloud Jenkins')
+      }
+      return
+    }
+
+    if (options.json) {
+      yield* Console.log(
+        JSON.stringify({ status: 'found', change_id: changeId, url: link }, null, 2),
+      )
+    } else if (options.xml) {
+      yield* Console.log(`<?xml version="1.0" encoding="UTF-8"?>`)
+      yield* Console.log(`<failures>`)
+      yield* Console.log(`  <status>found</status>`)
+      yield* Console.log(`  <change_id>${changeId}</change_id>`)
+      yield* Console.log(`  <url>${link}</url>`)
+      yield* Console.log(`</failures>`)
+    } else {
+      yield* Console.log(link)
+    }
+  })

package/src/cli/commands/list.ts

@@ -0,0 +1,239 @@
+import { Effect } from 'effect'
+import chalk from 'chalk'
+import { type ApiError, GerritApiService } from '@/api/gerrit'
+import type { ChangeInfo } from '@/schemas/gerrit'
+import { ConfigService, type ConfigError, type ConfigServiceImpl } from '@/services/config'
+
+export interface ListOptions {
+  status?: string
+  limit?: number
+  detailed?: boolean
+  reviewer?: boolean
+  allVerified?: boolean
+  filter?: string
+  json?: boolean
+  xml?: boolean
+}
+
+type LabelInfo = NonNullable<ChangeInfo['labels']>[string]
+
+// ── Label score helpers ────────────────────────────────────────────────────
+
+const getLabelScore = (label: LabelInfo): number | null => {
+  if (label.approved) return 2
+  if (label.rejected) return -2
+  if (label.recommended) return 1
+  if (label.disliked) return -1
+  if (label.value !== undefined && label.value !== 0) return label.value
+  return null
+}
+
+const fmtCR = (label: LabelInfo | undefined): string => {
+  if (!label) return chalk.gray('—')
+  const s = getLabelScore(label)
+  if (s === null || s === 0) return chalk.gray('0')
+  if (s >= 2) return chalk.bold.green('+2')
+  if (s === 1) return chalk.cyan('+1')
+  if (s === -1) return chalk.yellow('-1')
+  return chalk.bold.red('-2')
+}
+
+const fmtVerified = (label: LabelInfo | undefined): string => {
+  if (!label) return chalk.gray('—')
+  const s = getLabelScore(label)
+  if (s === null || s === 0) return chalk.gray('—')
+  if (s > 0) return chalk.green('V+')
+  return chalk.red('V-')
+}
+
+const fmtLabel = (label: LabelInfo | undefined): string => {
+  if (!label) return chalk.gray('—')
+  const s = getLabelScore(label)
+  if (s === null || s === 0) return chalk.gray('—')
+  if (s > 0) return chalk.green(`+${s}`)
+  return chalk.red(String(s))
+}
+
+// ── Time-ago ───────────────────────────────────────────────────────────────
+
+const timeAgo = (dateStr: string): string => {
+  const ms = Date.now() - new Date(dateStr.replace(' ', 'T').split('.')[0] + 'Z').getTime()
+  const mins = Math.floor(ms / 60000)
+  if (mins < 60) return `${mins}m ago`
+  const hrs = Math.floor(mins / 60)
+  if (hrs < 24) return `${hrs}h ago`
+  const days = Math.floor(hrs / 24)
+  if (days < 14) return `${days}d ago`
+  const weeks = Math.floor(days / 7)
+  if (weeks < 8) return `${weeks}w ago`
+  return dateStr.slice(0, 10)
+}
+
+// ── Table rendering ────────────────────────────────────────────────────────
+
+const COL_CHANGE = 8
+const COL_SUBJECT_MINE = 58
+const COL_SUBJECT_TEAM = 45
+const COL_OWNER = 20
+const COL_SCORE = 4
+const COL_UPDATED = 10
+
+const pad = (s: string, width: number): string => {
+  const visible = s.replace(/\x1b\[[0-9;]*m/g, '')
+  const extra = s.length - visible.length
+  return s.padEnd(width + extra)
+}
+
+const truncate = (s: string, max: number): string =>
+  s.length > max ? `${s.slice(0, max - 1)}…` : s
+
+const getOwnerLabel = (change: ChangeInfo): string =>
+  change.owner?.name ?? change.owner?.email ?? String(change.owner?._account_id ?? '—')
+
+const renderTableHeader = (showOwner: boolean): void => {
+  const h = chalk.bold
+  const colSubject = showOwner ? COL_SUBJECT_TEAM : COL_SUBJECT_MINE
+  const ownerCol = showOwner ? `  ${h(pad('Owner', COL_OWNER))}` : ''
+  console.log(
+    `  ${h(pad('Change', COL_CHANGE))}  ${h(pad('Subject', colSubject))}${ownerCol}  ` +
+      `${h(pad('CR', COL_SCORE))}  ${h(pad('QR', COL_SCORE))}  ` +
+      `${h(pad('LR', COL_SCORE))}  ${h(pad('Verified', 8))}  ${h('Updated')}`,
+  )
+  const d = '─'
+  const ownerDiv = showOwner ? `  ${d.repeat(COL_OWNER)}` : ''
+  console.log(
+    `  ${d.repeat(COL_CHANGE)}  ${d.repeat(colSubject)}${ownerDiv}  ` +
+      `${d.repeat(COL_SCORE)}  ${d.repeat(COL_SCORE)}  ` +
+      `${d.repeat(COL_SCORE)}  ${d.repeat(8)}  ${d.repeat(COL_UPDATED)}`,
+  )
+}
+
+const renderTableRow = (change: ChangeInfo, showOwner: boolean): void => {
+  const colSubject = showOwner ? COL_SUBJECT_TEAM : COL_SUBJECT_MINE
+  const num = chalk.cyan(pad(String(change._number), COL_CHANGE))
+  const subject = pad(truncate(change.subject, colSubject), colSubject)
+  const ownerCol = showOwner
+    ? `  ${pad(truncate(getOwnerLabel(change), COL_OWNER), COL_OWNER)}`
+    : ''
+  const cr = pad(fmtCR(change.labels?.['Code-Review']), COL_SCORE)
+  const qr = pad(fmtLabel(change.labels?.['QA-Review']), COL_SCORE)
+  const lr = pad(fmtLabel(change.labels?.['Lint-Review']), COL_SCORE)
+  const verified = pad(fmtVerified(change.labels?.['Verified']), 8)
+  const updated = timeAgo(change.updated ?? change.created ?? '')
+  console.log(`  ${num}  ${subject}${ownerCol}  ${cr}  ${qr}  ${lr}  ${verified}  ${updated}`)
+}
+
+const renderDetailed = (change: ChangeInfo): void => {
+  console.log(`${chalk.bold.cyan('Change:')}   ${chalk.bold(String(change._number))}`)
+  console.log(`${chalk.bold.cyan('Subject:')}  ${change.subject}`)
+  console.log(`${chalk.bold.cyan('Status:')}   ${change.status}`)
+  console.log(`${chalk.bold.cyan('Project:')}  ${change.project}`)
+  console.log(`${chalk.bold.cyan('Branch:')}   ${change.branch}`)
+  if (change.owner?.name) console.log(`${chalk.bold.cyan('Owner:')}    ${change.owner.name}`)
+  if (change.updated) console.log(`${chalk.bold.cyan('Updated:')}  ${timeAgo(change.updated)}`)
+
+  const labels = change.labels
+  if (labels && Object.keys(labels).length > 0) {
+    const scores = Object.entries(labels)
+      .map(([name, info]) => {
+        const s = getLabelScore(info)
+        if (s === null) return null
+        const formatted = s > 0 ? chalk.green(`+${s}`) : chalk.red(String(s))
+        return `${name}:${formatted}`
+      })
+      .filter((x): x is string => x !== null)
+    if (scores.length > 0) {
+      console.log(`${chalk.bold.cyan('Reviews:')}  ${scores.join('  ')}`)
+    }
+  }
+}
+
+// ── Command ────────────────────────────────────────────────────────────────
+
+export const listCommand = (
+  options: ListOptions,
+): Effect.Effect<void, ApiError | ConfigError, ConfigServiceImpl | GerritApiService> =>
+  Effect.gen(function* () {
+    const configService = yield* ConfigService
+    const credentials = yield* configService.getCredentials
+    const gerritApi = yield* GerritApiService
+
+    const status = options.status ?? 'open'
+    const limit = options.limit ?? 25
+    const user = credentials.username
+
+    const baseQuery = options.reviewer
+      ? `(reviewer:${user} OR cc:${user}) status:${status}`
+      : `owner:${user} status:${status}`
+    const query = options.filter ? `${baseQuery} ${options.filter}` : baseQuery
+
+    const changes = yield* gerritApi.listChanges(query)
+    const limited = changes.slice(0, limit)
+
+    if (options.json) {
+      console.log(
+        JSON.stringify(
+          {
+            status: 'success',
+            count: limited.length,
+            changes: limited.map((c) => ({
+              number: c._number,
+              subject: c.subject,
+              project: c.project,
+              branch: c.branch,
+              status: c.status,
+              change_id: c.change_id,
+              ...(c.updated ? { updated: c.updated } : {}),
+              ...(c.owner?.name ? { owner: c.owner.name } : {}),
+              ...(c.labels ? { labels: c.labels } : {}),
+            })),
+          },
+          null,
+          2,
+        ),
+      )
+      return
+    }
+
+    if (options.xml) {
+      console.log(`<?xml version="1.0" encoding="UTF-8"?>`)
+      console.log(`<changes count="${limited.length}">`)
+      for (const c of limited) {
+        console.log(`  <change>`)
+        console.log(`    <number>${c._number}</number>`)
+        console.log(`    <subject><![CDATA[${c.subject}]]></subject>`)
+        console.log(`    <project>${c.project}</project>`)
+        console.log(`    <branch>${c.branch}</branch>`)
+        console.log(`    <status>${c.status}</status>`)
+        console.log(`    <change_id>${c.change_id}</change_id>`)
+        if (c.updated) console.log(`    <updated>${c.updated}</updated>`)
+        if (c.owner?.name) console.log(`    <owner>${c.owner.name}</owner>`)
+        console.log(`  </change>`)
+      }
+      console.log(`</changes>`)
+      return
+    }
+
+    if (limited.length === 0) {
+      console.log(
+        chalk.dim(options.reviewer ? 'No changes need your review.' : 'No changes found.'),
+      )
+      return
+    }
+
+    if (options.detailed) {
+      for (const [i, change] of limited.entries()) {
+        if (i > 0) console.log('')
+        renderDetailed(change)
+      }
+      return
+    }
+
+    const showOwner = options.reviewer === true
+    console.log('')
+    renderTableHeader(showOwner)
+    for (const change of limited) {
+      renderTableRow(change, showOwner)
+    }
+    console.log('')
+  })

package/src/cli/commands/rebase.ts

@@ -5,6 +5,7 @@ import { escapeXML, sanitizeCDATA } from '@/utils/shell-safety'
 
 interface RebaseOptions {
   base?: string
+  allowConflicts?: boolean
   xml?: boolean
   json?: boolean
 }
@@ -29,7 +30,10 @@ export const rebaseCommand = (
     const resolvedChangeId = changeId || (yield* getChangeIdFromHead())
 
     // Perform the rebase - this returns the rebased change info
-    const change = yield* gerritApi.rebaseChange(resolvedChangeId, { base: options.base })
+    const change = yield* gerritApi.rebaseChange(resolvedChangeId, {
+      base: options.base,
+      allowConflicts: options.allowConflicts,
+    })
 
     if (options.json) {
       console.log(

package/src/cli/commands/retrigger.ts

@@ -0,0 +1,91 @@
+import { Effect } from 'effect'
+import chalk from 'chalk'
+import { input } from '@inquirer/prompts'
+import { type ApiError, GerritApiService, type GerritApiServiceImpl } from '@/api/gerrit'
+import { type ConfigError, ConfigService, type ConfigServiceImpl } from '@/services/config'
+import { getChangeIdFromHead, type GitError, type NoChangeIdError } from '@/utils/git-commit'
+
+export const RETRIGGER_HELP_TEXT = `
+Examples:
+  # Retrigger CI for the change in HEAD commit (auto-detected)
+  $ ger retrigger
+
+  # Retrigger CI for a specific change
+  $ ger retrigger 12345
+
+Notes:
+  - The retrigger comment is saved in config (set during "ger setup" or prompted on first use)
+  - Auto-detection reads the Change-Id footer from HEAD commit`
+
+export interface RetriggerOptions {
+  xml?: boolean
+  json?: boolean
+}
+
+export const retriggerCommand = (
+  changeId: string | undefined,
+  options: RetriggerOptions,
+): Effect.Effect<
+  void,
+  ApiError | ConfigError | GitError | NoChangeIdError | Error,
+  GerritApiServiceImpl | ConfigServiceImpl
+> =>
+  Effect.gen(function* () {
+    // Resolve change ID — explicit arg or auto-detect from HEAD
+    const resolvedChangeId = changeId !== undefined ? changeId : yield* getChangeIdFromHead()
+
+    // Get retrigger comment from config
+    const configService = yield* ConfigService
+    let retriggerComment = yield* configService.getRetriggerComment
+
+    // If not configured, prompt and save
+    if (!retriggerComment) {
+      if (!options.xml && !options.json) {
+        console.log(chalk.yellow('No retrigger comment configured.'))
+        console.log(
+          chalk.dim('This comment will be posted to trigger CI. It will be saved to config.'),
+        )
+      }
+
+      const prompted = yield* Effect.tryPromise({
+        try: () =>
+          input({
+            message: 'CI retrigger comment',
+          }),
+        catch: (e) =>
+          new Error(e instanceof Error ? e.message : 'Failed to read retrigger comment'),
+      })
+
+      if (!prompted.trim()) {
+        return yield* Effect.fail(new Error('Retrigger comment cannot be empty'))
+      }
+
+      retriggerComment = prompted.trim()
+      yield* configService.saveRetriggerComment(retriggerComment)
+
+      if (!options.xml && !options.json) {
+        console.log(chalk.dim('  Retrigger comment saved to config'))
+      }
+    }
+
+    // Post the comment
+    const gerritApi = yield* GerritApiService
+
+    if (!options.xml && !options.json) {
+      console.log(chalk.bold(`Retriggering CI for change ${chalk.cyan(resolvedChangeId)}...`))
+    }
+
+    yield* gerritApi.postReview(resolvedChangeId, { message: retriggerComment })
+
+    if (options.json) {
+      console.log(JSON.stringify({ status: 'success', change_id: resolvedChangeId }, null, 2))
+    } else if (options.xml) {
+      console.log(`<?xml version="1.0" encoding="UTF-8"?>`)
+      console.log(`<retrigger>`)
+      console.log(`  <status>success</status>`)
+      console.log(`  <change_id><![CDATA[${resolvedChangeId}]]></change_id>`)
+      console.log(`</retrigger>`)
+    } else {
+      console.log(chalk.green('  ✓ CI retrigger comment posted'))
+    }
+  })