@aaronshaf/ger 2.0.0 → 2.0.2

package/src/cli/commands/install-hook.ts

@@ -0,0 +1,59 @@
+import { Effect, Console } from 'effect'
+import chalk from 'chalk'
+import {
+  CommitHookService,
+  type CommitHookServiceImpl,
+  type HookInstallError,
+  type NotGitRepoError,
+} from '@/services/commit-hook'
+import { type ConfigError, type ConfigServiceImpl } from '@/services/config'
+
+export interface InstallHookOptions {
+  force?: boolean
+  xml?: boolean
+}
+
+export type InstallHookErrors = ConfigError | HookInstallError | NotGitRepoError
+
+export const installHookCommand = (
+  options: InstallHookOptions,
+): Effect.Effect<void, InstallHookErrors, CommitHookServiceImpl | ConfigServiceImpl> =>
+  Effect.gen(function* () {
+    const commitHookService = yield* CommitHookService
+
+    // Check if hook already exists using service method
+    const hookExists = yield* commitHookService.hasHook()
+
+    if (hookExists && !options.force) {
+      if (options.xml) {
+        yield* Console.log('<?xml version="1.0" encoding="UTF-8"?>')
+        yield* Console.log('<install_hook_result>')
+        yield* Console.log('  <status>skipped</status>')
+        yield* Console.log('  <message><![CDATA[commit-msg hook already installed]]></message>')
+        yield* Console.log('  <hint><![CDATA[Use --force to overwrite]]></hint>')
+        yield* Console.log('</install_hook_result>')
+      } else {
+        yield* Console.log(chalk.yellow('commit-msg hook already installed'))
+        yield* Console.log(chalk.dim('Use --force to overwrite'))
+      }
+      return
+    }
+
+    if (hookExists && options.force) {
+      if (!options.xml) {
+        yield* Console.log(chalk.yellow('Overwriting existing commit-msg hook...'))
+      }
+    }
+
+    // Install the hook (service logs progress messages in non-XML mode)
+    yield* commitHookService.installHook()
+
+    // Only output XML here - service already logs success message for non-XML mode
+    if (options.xml) {
+      yield* Console.log('<?xml version="1.0" encoding="UTF-8"?>')
+      yield* Console.log('<install_hook_result>')
+      yield* Console.log('  <status>success</status>')
+      yield* Console.log('  <message><![CDATA[commit-msg hook installed successfully]]></message>')
+      yield* Console.log('</install_hook_result>')
+    }
+  })

package/src/cli/commands/rebase.ts

@@ -1,5 +1,7 @@
 import { Effect } from 'effect'
 import { type ApiError, GerritApiService } from '@/api/gerrit'
+import { GitError, NoChangeIdError, getChangeIdFromHead } from '@/utils/git-commit'
+import { escapeXML, sanitizeCDATA } from '@/utils/shell-safety'
 
 interface RebaseOptions {
   base?: string
@@ -9,7 +11,7 @@ interface RebaseOptions {
 /**
  * Rebases a Gerrit change onto the target branch or specified base.
  *
- * @param changeId - Change number or Change-ID to rebase
+ * @param changeId - Change number or Change-ID to rebase (optional, auto-detects from HEAD if not provided)
  * @param options - Configuration options
  * @param options.base - Optional base revision to rebase onto (default: target branch HEAD)
  * @param options.xml - Whether to output in XML format for LLM consumption
@@ -18,28 +20,25 @@ interface RebaseOptions {
 export const rebaseCommand = (
   changeId?: string,
   options: RebaseOptions = {},
-): Effect.Effect<void, ApiError, GerritApiService> =>
+): Effect.Effect<void, never, GerritApiService> =>
   Effect.gen(function* () {
     const gerritApi = yield* GerritApiService
 
-    if (!changeId || changeId.trim() === '') {
-      console.error('✗ Change ID is required')
-      console.error('  Usage: ger rebase <change-id> [--base <ref>]')
-      return
-    }
+    // Auto-detect Change-ID from HEAD commit if not provided
+    const resolvedChangeId = changeId || (yield* getChangeIdFromHead())
 
     // Perform the rebase - this returns the rebased change info
-    const change = yield* gerritApi.rebaseChange(changeId, { base: options.base })
+    const change = yield* gerritApi.rebaseChange(resolvedChangeId, { base: options.base })
 
     if (options.xml) {
       console.log(`<?xml version="1.0" encoding="UTF-8"?>`)
       console.log(`<rebase_result>`)
       console.log(`  <status>success</status>`)
       console.log(`  <change_number>${change._number}</change_number>`)
-      console.log(`  <subject><![CDATA[${change.subject}]]></subject>`)
-      console.log(`  <branch>${change.branch}</branch>`)
+      console.log(`  <subject><![CDATA[${sanitizeCDATA(change.subject)}]]></subject>`)
+      console.log(`  <branch>${escapeXML(change.branch)}</branch>`)
       if (options.base) {
-        console.log(`  <base><![CDATA[${options.base}]]></base>`)
+        console.log(`  <base><![CDATA[${sanitizeCDATA(options.base)}]]></base>`)
       }
       console.log(`</rebase_result>`)
     } else {
@@ -49,4 +48,24 @@ export const rebaseCommand = (
         console.log(`  Base: ${options.base}`)
       }
     }
-  })
+  }).pipe(
+    // Regional error boundary for the entire command
+    Effect.catchAll((error: ApiError | GitError | NoChangeIdError) =>
+      Effect.sync(() => {
+        const errorMessage =
+          error instanceof GitError || error instanceof NoChangeIdError || error instanceof Error
+            ? error.message
+            : String(error)
+
+        if (options.xml) {
+          console.log(`<?xml version="1.0" encoding="UTF-8"?>`)
+          console.log(`<rebase_result>`)
+          console.log(`  <status>error</status>`)
+          console.log(`  <error><![CDATA[${sanitizeCDATA(errorMessage)}]]></error>`)
+          console.log(`</rebase_result>`)
+        } else {
+          console.error(`✗ Error: ${errorMessage}`)
+        }
+      }),
+    ),
+  )

package/src/cli/commands/show.ts

@@ -48,6 +48,7 @@ interface ChangeDetails {
   created?: string
   updated?: string
   commitMessage: string
+  topic?: string
 }
 
 const getChangeDetails = (
@@ -71,6 +72,7 @@ const getChangeDetails = (
       created: change.created,
       updated: change.updated,
       commitMessage: change.subject, // For now, using subject as commit message
+      topic: change.topic,
     }
   })
 
@@ -142,6 +144,9 @@ const formatShowPretty = (
   console.log(`   Project: ${changeDetails.project}`)
   console.log(`   Branch: ${changeDetails.branch}`)
   console.log(`   Status: ${changeDetails.status}`)
+  if (changeDetails.topic) {
+    console.log(`   Topic: ${changeDetails.topic}`)
+  }
   console.log(`   Owner: ${changeDetails.owner.name || changeDetails.owner.email || 'Unknown'}`)
   console.log(
     `   Created: ${changeDetails.created ? formatDate(changeDetails.created) : 'Unknown'}`,
@@ -220,6 +225,7 @@ const formatShowJson = async (
       status: changeDetails.status,
       project: changeDetails.project,
       branch: changeDetails.branch,
+      topic: changeDetails.topic,
       owner: removeUndefined(changeDetails.owner),
       created: changeDetails.created,
       updated: changeDetails.updated,
@@ -301,6 +307,9 @@ const formatShowXml = async (
   xmlParts.push(`    <status>${escapeXML(changeDetails.status)}</status>`)
   xmlParts.push(`    <project>${escapeXML(changeDetails.project)}</project>`)
   xmlParts.push(`    <branch>${escapeXML(changeDetails.branch)}</branch>`)
+  if (changeDetails.topic) {
+    xmlParts.push(`    <topic><![CDATA[${sanitizeCDATA(changeDetails.topic)}]]></topic>`)
+  }
   xmlParts.push(`    <owner>`)
   if (changeDetails.owner.name) {
     xmlParts.push(`      <name><![CDATA[${sanitizeCDATA(changeDetails.owner.name)}]]></name>`)

package/src/cli/commands/topic.ts

@@ -0,0 +1,108 @@
+import { Effect } from 'effect'
+import { type ApiError, GerritApiService } from '@/api/gerrit'
+import { sanitizeCDATA } from '@/utils/shell-safety'
+import { getChangeIdFromHead, GitError, NoChangeIdError } from '@/utils/git-commit'
+
+export const TOPIC_HELP_TEXT = `
+Examples:
+  # View current topic (auto-detect from HEAD)
+  $ ger topic
+
+  # View topic for specific change
+  $ ger topic 12345
+
+  # Set topic on a change
+  $ ger topic 12345 my-feature
+
+  # Remove topic from a change
+  $ ger topic 12345 --delete
+  $ ger topic --delete  # auto-detect from HEAD
+
+Note: When no change-id is provided, it will be auto-detected from the HEAD commit.`
+
+interface TopicOptions {
+  xml?: boolean
+  delete?: boolean
+}
+
+/**
+ * Manages topic for a Gerrit change.
+ *
+ * - No topic argument: get current topic
+ * - With topic argument: set topic
+ * - With --delete flag: remove topic
+ *
+ * @param changeId - Change number or Change-ID (auto-detects from HEAD if not provided)
+ * @param topic - Optional topic to set
+ * @param options - Configuration options
+ * @returns Effect that completes when the operation finishes
+ */
+export const topicCommand = (
+  changeId: string | undefined,
+  topic: string | undefined,
+  options: TopicOptions = {},
+): Effect.Effect<void, ApiError | GitError | NoChangeIdError, GerritApiService> =>
+  Effect.gen(function* () {
+    const gerritApi = yield* GerritApiService
+
+    // Auto-detect Change-ID from HEAD commit if not provided
+    const resolvedChangeId = changeId?.trim() || (yield* getChangeIdFromHead())
+
+    // Handle delete operation
+    if (options.delete) {
+      yield* gerritApi.deleteTopic(resolvedChangeId)
+
+      if (options.xml) {
+        console.log(`<?xml version="1.0" encoding="UTF-8"?>`)
+        console.log(`<topic_result>`)
+        console.log(`  <status>success</status>`)
+        console.log(`  <action>deleted</action>`)
+        console.log(`  <change_id><![CDATA[${sanitizeCDATA(resolvedChangeId)}]]></change_id>`)
+        console.log(`</topic_result>`)
+      } else {
+        console.log(`✓ Removed topic from change ${resolvedChangeId}`)
+      }
+      return
+    }
+
+    // Handle set operation
+    if (topic !== undefined && topic.trim() !== '') {
+      const newTopic = yield* gerritApi.setTopic(resolvedChangeId, topic)
+
+      if (options.xml) {
+        console.log(`<?xml version="1.0" encoding="UTF-8"?>`)
+        console.log(`<topic_result>`)
+        console.log(`  <status>success</status>`)
+        console.log(`  <action>set</action>`)
+        console.log(`  <change_id><![CDATA[${sanitizeCDATA(resolvedChangeId)}]]></change_id>`)
+        console.log(`  <topic><![CDATA[${sanitizeCDATA(newTopic)}]]></topic>`)
+        console.log(`</topic_result>`)
+      } else {
+        console.log(`✓ Set topic on change ${resolvedChangeId}: ${newTopic}`)
+      }
+      return
+    }
+
+    // Handle get operation (default)
+    const currentTopic = yield* gerritApi.getTopic(resolvedChangeId)
+
+    if (options.xml) {
+      console.log(`<?xml version="1.0" encoding="UTF-8"?>`)
+      console.log(`<topic_result>`)
+      console.log(`  <status>success</status>`)
+      console.log(`  <action>get</action>`)
+      console.log(`  <change_id><![CDATA[${sanitizeCDATA(resolvedChangeId)}]]></change_id>`)
+      if (currentTopic) {
+        console.log(`  <topic><![CDATA[${sanitizeCDATA(currentTopic)}]]></topic>`)
+      } else {
+        console.log(`  <topic />`)
+      }
+      console.log(`</topic_result>`)
+    } else {
+      if (currentTopic) {
+        console.log(currentTopic)
+      } else {
+        console.log(`No topic set for change ${resolvedChangeId}`)
+      }
+    }
+  })

package/src/cli/register-commands.ts

@@ -9,15 +9,17 @@ import { abandonCommand } from './commands/abandon'
 import { restoreCommand } from './commands/restore'
 import { rebaseCommand } from './commands/rebase'
 import { submitCommand } from './commands/submit'
+import { topicCommand, TOPIC_HELP_TEXT } from './commands/topic'
 import { voteCommand } from './commands/vote'
 import { projectsCommand } from './commands/projects'
 import { buildStatusCommand, BUILD_STATUS_HELP_TEXT } from './commands/build-status'
 import { checkoutCommand, CHECKOUT_HELP_TEXT } from './commands/checkout'
-import { commentCommand } from './commands/comment'
+import { commentCommand, COMMENT_HELP_TEXT } from './commands/comment'
 import { commentsCommand } from './commands/comments'
 import { diffCommand } from './commands/diff'
 import { extractUrlCommand } from './commands/extract-url'
 import { incomingCommand } from './commands/incoming'
+import { installHookCommand } from './commands/install-hook'
 import { mineCommand } from './commands/mine'
 import { openCommand } from './commands/open'
 import { pushCommand, PUSH_HELP_TEXT } from './commands/push'
@@ -106,38 +108,7 @@ export function registerCommands(program: Command): void {
     .option('--unresolved', 'Mark comment as unresolved (requires human attention)')
     .option('--batch', 'Read batch comments from stdin as JSON (see examples below)')
     .option('--xml', 'XML output for LLM consumption')
-    .addHelpText(
-      'after',
-      `
-Examples:
-  # Post a general comment on a change (using change number)
-  $ ger comment 12345 -m "Looks good to me!"
-
-  # Post a comment using Change-ID
-  $ ger comment If5a3ae8cb5a107e187447802358417f311d0c4b1 -m "LGTM"
-
-  # Post a comment using piped input (useful for multi-line comments or scripts)
-  $ echo "This is a comment from stdin!" | ger comment 12345
-  $ cat review-notes.txt | ger comment 12345
-
-  # Post a line-specific comment (line number from NEW file version)
-  $ ger comment 12345 --file src/main.js --line 42 -m "Consider using const here"
-
-  # Post an unresolved comment requiring human attention
-  $ ger comment 12345 --file src/api.js --line 15 -m "Security concern" --unresolved
-
-  # Post multiple comments using batch mode
-  $ echo '{"message": "Review complete", "comments": [
-      {"file": "src/main.js", "line": 10, "message": "Good refactor"},
-      {"file": "src/api.js", "line": 25, "message": "Check error handling", "unresolved": true}
-    ]}' | ger comment 12345 --batch
-
-Note:
-  - Both change number (e.g., 12345) and Change-ID (e.g., If5a3ae8...) formats are accepted
-  - Line numbers refer to the actual line numbers in the NEW version of the file,
-    NOT the line numbers shown in the diff view. To find the correct line number,
-    look at the file after all changes have been applied.`,
-    )
+    .addHelpText('after', COMMENT_HELP_TEXT)
     .action(async (changeId, options) => {
       await executeEffect(
         commentCommand(changeId, options).pipe(
@@ -285,8 +256,8 @@ Note:
 
   // rebase command
   program
-    .command('rebase <change-id>')
-    .description('Rebase a change onto target branch (accepts change number or Change-ID)')
+    .command('rebase [change-id]')
+    .description('Rebase a change onto target branch (auto-detects from HEAD if not provided)')
     .option('--base <ref>', 'Base revision to rebase onto (default: target branch HEAD)')
     .option('--xml', 'XML output for LLM consumption')
     .action(async (changeId, options) => {
@@ -316,6 +287,24 @@ Note:
       )
     })
 
+  // topic command
+  program
+    .command('topic [change-id] [topic]')
+    .description('Get, set, or remove topic for a change (auto-detects from HEAD if not specified)')
+    .option('--delete', 'Remove the topic from the change')
+    .option('--xml', 'XML output for LLM consumption')
+    .addHelpText('after', TOPIC_HELP_TEXT)
+    .action(async (changeId, topic, options) => {
+      await executeEffect(
+        topicCommand(changeId, topic, options).pipe(
+          Effect.provide(GerritApiServiceLive),
+          Effect.provide(ConfigServiceLive),
+        ),
+        options,
+        'topic_result',
+      )
+    })
+
   // vote command
   program
     .command('vote <change-id>')
@@ -528,6 +517,39 @@ Note:
       }
     })
 
+  // install-hook command
+  program
+    .command('install-hook')
+    .description('Install the Gerrit commit-msg hook for automatic Change-Id generation')
+    .option('--force', 'Overwrite existing hook')
+    .option('--xml', 'XML output for LLM consumption')
+    .addHelpText(
+      'after',
+      `
+Examples:
+  # Install the commit-msg hook
+  $ ger install-hook
+
+  # Force reinstall (overwrite existing)
+  $ ger install-hook --force
+
+Note:
+  - Downloads hook from your configured Gerrit server
+  - Installs to .git/hooks/commit-msg
+  - Makes hook executable (chmod +x)
+  - Required for commits to have Change-Id footers`,
+    )
+    .action(async (options) => {
+      await executeEffect(
+        installHookCommand(options).pipe(
+          Effect.provide(CommitHookServiceLive),
+          Effect.provide(ConfigServiceLive),
+        ),
+        options,
+        'install_hook_result',
+      )
+    })
+
   // push command
   program
     .command('push')

package/src/schemas/gerrit.ts

@@ -118,6 +118,7 @@ export const ChangeInfo: Schema.Schema<{
   readonly work_in_progress?: boolean
   readonly current_revision?: string
   readonly revisions?: Record<string, RevisionInfoType>
+  readonly topic?: string
 }> = Schema.Struct({
   id: Schema.String,
   project: Schema.String,
@@ -182,6 +183,7 @@ export const ChangeInfo: Schema.Schema<{
   work_in_progress: Schema.optional(Schema.Boolean),
   current_revision: Schema.optional(Schema.String),
   revisions: Schema.optional(Schema.Record({ key: Schema.String, value: Schema.Any })),
+  topic: Schema.optional(Schema.String),
 })
 export type ChangeInfo = Schema.Schema.Type<typeof ChangeInfo>
 

package/tests/rebase.test.ts

@@ -170,7 +170,7 @@ describe('rebase command', () => {
     expect(output).toContain('</rebase_result>')
   })
 
-  it('should handle not found errors gracefully', async () => {
+  it('should handle not found errors gracefully with pretty output', async () => {
     server.use(
       http.post('*/a/changes/99999/revisions/current/rebase', () => {
         return HttpResponse.text('Change not found', { status: 404 })
@@ -183,25 +183,86 @@ describe('rebase command', () => {
       Effect.provide(mockConfigLayer),
     )
 
-    // Should fail when change is not found
-    await expect(Effect.runPromise(program)).rejects.toThrow()
+    // Error boundary catches and outputs to console.error
+    await Effect.runPromise(program)
+
+    const errorOutput = mockConsoleError.mock.calls.map((call) => call[0]).join('\n')
+    expect(errorOutput).toContain('Error:')
   })
 
-  it('should show error when change ID is not provided', async () => {
+  it('should handle not found errors with XML output when --xml flag is used', async () => {
+    server.use(
+      http.post('*/a/changes/99999/revisions/current/rebase', () => {
+        return HttpResponse.text('Change not found', { status: 404 })
+      }),
+    )
+
+    const mockConfigLayer = Layer.succeed(ConfigService, createMockConfigService())
+    const program = rebaseCommand('99999', { xml: true }).pipe(
+      Effect.provide(GerritApiServiceLive),
+      Effect.provide(mockConfigLayer),
+    )
+
+    // Error boundary catches and outputs XML error
+    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('<rebase_result>')
+    expect(output).toContain('<status>error</status>')
+    expect(output).toContain('<error><![CDATA[')
+    expect(output).toContain('</rebase_result>')
+  })
+
+  it('should output error to console.error when no change ID and HEAD has no Change-Id', async () => {
     const mockConfigLayer = Layer.succeed(ConfigService, createMockConfigService())
     const program = rebaseCommand(undefined, {}).pipe(
       Effect.provide(GerritApiServiceLive),
       Effect.provide(mockConfigLayer),
     )
 
+    // Error boundary catches NoChangeIdError and outputs to console.error
     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 rebase <change-id>')
+    expect(errorOutput).toContain('Error:')
+    expect(errorOutput).toContain('No Change-ID found in HEAD commit')
   })
 
-  it('should handle rebase conflicts', async () => {
+  it('should output XML error when no change ID and HEAD has no Change-Id with --xml flag', async () => {
+    const mockConfigLayer = Layer.succeed(ConfigService, createMockConfigService())
+    const program = rebaseCommand(undefined, { xml: true }).pipe(
+      Effect.provide(GerritApiServiceLive),
+      Effect.provide(mockConfigLayer),
+    )
+
+    // Error boundary catches NoChangeIdError and outputs XML error
+    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('<rebase_result>')
+    expect(output).toContain('<status>error</status>')
+    expect(output).toContain('No Change-ID found in HEAD commit')
+    expect(output).toContain('</rebase_result>')
+  })
+
+  it('should treat empty string as missing change ID and auto-detect', async () => {
+    const mockConfigLayer = Layer.succeed(ConfigService, createMockConfigService())
+    const program = rebaseCommand('', {}).pipe(
+      Effect.provide(GerritApiServiceLive),
+      Effect.provide(mockConfigLayer),
+    )
+
+    // Empty string triggers auto-detection, which fails with NoChangeIdError
+    await Effect.runPromise(program)
+
+    const errorOutput = mockConsoleError.mock.calls.map((call) => call[0]).join('\n')
+    expect(errorOutput).toContain('Error:')
+    expect(errorOutput).toContain('No Change-ID found in HEAD commit')
+  })
+
+  it('should handle rebase conflicts gracefully', async () => {
     server.use(
       http.post('*/a/changes/12345/revisions/current/rebase', () => {
         return HttpResponse.text('Rebase conflict detected', { status: 409 })
@@ -214,11 +275,14 @@ describe('rebase command', () => {
       Effect.provide(mockConfigLayer),
     )
 
-    // Should throw/fail
-    await expect(Effect.runPromise(program)).rejects.toThrow()
+    // Error boundary catches and outputs to console.error
+    await Effect.runPromise(program)
+
+    const errorOutput = mockConsoleError.mock.calls.map((call) => call[0]).join('\n')
+    expect(errorOutput).toContain('Error:')
   })
 
-  it('should handle API errors', async () => {
+  it('should handle API errors gracefully', async () => {
     server.use(
       http.post('*/a/changes/12345/revisions/current/rebase', () => {
         return HttpResponse.text('Forbidden', { status: 403 })
@@ -231,8 +295,11 @@ describe('rebase command', () => {
       Effect.provide(mockConfigLayer),
     )
 
-    // Should throw/fail
-    await expect(Effect.runPromise(program)).rejects.toThrow()
+    // Error boundary catches and outputs to console.error
+    await Effect.runPromise(program)
+
+    const errorOutput = mockConsoleError.mock.calls.map((call) => call[0]).join('\n')
+    expect(errorOutput).toContain('Error:')
   })
 
   it('should handle changes that are already up to date', async () => {
@@ -248,11 +315,14 @@ describe('rebase command', () => {
       Effect.provide(mockConfigLayer),
     )
 
-    // Should throw/fail
-    await expect(Effect.runPromise(program)).rejects.toThrow()
+    // Error boundary catches and outputs to console.error
+    await Effect.runPromise(program)
+
+    const errorOutput = mockConsoleError.mock.calls.map((call) => call[0]).join('\n')
+    expect(errorOutput).toContain('Error:')
   })
 
-  it('should handle network errors', async () => {
+  it('should handle network errors gracefully', async () => {
     server.use(
       http.post('*/a/changes/12345/revisions/current/rebase', () => {
         return HttpResponse.error()
@@ -265,7 +335,34 @@ describe('rebase command', () => {
       Effect.provide(mockConfigLayer),
     )
 
-    // Should throw/fail
-    await expect(Effect.runPromise(program)).rejects.toThrow()
+    // Error boundary catches and outputs to console.error
+    await Effect.runPromise(program)
+
+    const errorOutput = mockConsoleError.mock.calls.map((call) => call[0]).join('\n')
+    expect(errorOutput).toContain('Error:')
+  })
+
+  it('should handle network errors with XML output', async () => {
+    server.use(
+      http.post('*/a/changes/12345/revisions/current/rebase', () => {
+        return HttpResponse.error()
+      }),
+    )
+
+    const mockConfigLayer = Layer.succeed(ConfigService, createMockConfigService())
+    const program = rebaseCommand('12345', { xml: true }).pipe(
+      Effect.provide(GerritApiServiceLive),
+      Effect.provide(mockConfigLayer),
+    )
+
+    // Error boundary catches and outputs XML error
+    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('<rebase_result>')
+    expect(output).toContain('<status>error</status>')
+    expect(output).toContain('<error><![CDATA[')
+    expect(output).toContain('</rebase_result>')
   })
 })