@aaronshaf/ger 3.0.1 → 3.0.2

package/docs/prd/commands.md

@@ -28,7 +28,65 @@ ger show              # Auto-detect from HEAD
 - Full diff
 - All comments with context
 
-Reviewer listing for a specific change is provided by `show` (there is no separate `list-reviewers` command).
+### files
+
+List files changed in a change.
+
+```bash
+ger files [change-id]
+ger files 12345
+ger files              # Auto-detect from HEAD
+ger files 12345 --json
+ger files 12345 --xml
+```
+
+| Option | Description |
+|--------|-------------|
+| `--json` | Output as JSON |
+| `--xml` | Output as XML for LLM consumption |
+
+**Output:** One file per line with status prefix (`M` modified, `A` added, `D` deleted, `R` renamed). Magic files (`/COMMIT_MSG`, `/MERGE_LIST`, `/PATCHSET_LEVEL`) are filtered out.
+
+**JSON output:**
+```json
+{
+  "status": "success",
+  "change_id": "12345",
+  "files": [
+    { "path": "src/foo.ts", "status": "M", "lines_inserted": 10, "lines_deleted": 2 }
+  ]
+}
+```
+
+### reviewers
+
+List reviewers on a change.
+
+```bash
+ger reviewers [change-id]
+ger reviewers 12345
+ger reviewers          # Auto-detect from HEAD
+ger reviewers 12345 --json
+ger reviewers 12345 --xml
+```
+
+| Option | Description |
+|--------|-------------|
+| `--json` | Output as JSON |
+| `--xml` | Output as XML for LLM consumption |
+
+**Output:** One reviewer per line in `Name <email>` format (or email alone for email-only accounts).
+
+**JSON output:**
+```json
+{
+  "status": "success",
+  "change_id": "12345",
+  "reviewers": [
+    { "account_id": 1001, "name": "Alice Smith", "email": "alice@example.com", "username": "alice" }
+  ]
+}
+```
 
 ### diff
 

package/package.json

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

package/src/api/gerrit.ts

@@ -18,6 +18,7 @@ import {
   GroupDetailInfo,
   AccountInfo,
 } from '@/schemas/gerrit'
+import { ReviewerListItem } from '@/schemas/reviewer'
 import { filterMeaningfulMessages } from '@/utils/message-filters'
 import { convertToUnifiedDiff } from '@/utils/diff-formatters'
 import { ConfigService } from '@/services/config'
@@ -86,6 +87,7 @@ export interface GerritApiServiceImpl {
   readonly getGroup: (groupId: string) => Effect.Effect<GroupInfo, ApiError>
   readonly getGroupDetail: (groupId: string) => Effect.Effect<GroupDetailInfo, ApiError>
   readonly getGroupMembers: (groupId: string) => Effect.Effect<readonly AccountInfo[], ApiError>
+  readonly getReviewers: (changeId: string) => Effect.Effect<readonly ReviewerListItem[], ApiError>
   readonly removeReviewer: (
     changeId: string,
     accountId: string,
@@ -227,13 +229,8 @@ export const GerritApiServiceLive: Layer.Layer<GerritApiService, never, ConfigSe
           const { credentials, authHeader } = yield* getCredentialsAndAuth
           let url = `${credentials.host}/a/projects/`
           if (options?.pattern) url += `?p=${encodeURIComponent(options.pattern)}`
-          const projectsRecord = yield* makeRequest(
-            url,
-            authHeader,
-            'GET',
-            undefined,
-            Schema.Record({ key: Schema.String, value: ProjectInfo }),
-          )
+          const schema = Schema.Record({ key: Schema.String, value: ProjectInfo })
+          const projectsRecord = yield* makeRequest(url, authHeader, 'GET', undefined, schema)
           return Object.values(projectsRecord).sort((a, b) => a.name.localeCompare(b.name))
         })
 
@@ -581,6 +578,15 @@ export const GerritApiServiceLive: Layer.Layer<GerritApiService, never, ConfigSe
           return yield* makeRequest(url, authHeader, 'GET', undefined, Schema.Array(AccountInfo))
         })
 
+      const getReviewers = (changeId: string) =>
+        Effect.gen(function* () {
+          const { credentials, authHeader } = yield* getCredentialsAndAuth
+          const normalized = yield* normalizeAndValidate(changeId)
+          const url = `${credentials.host}/a/changes/${encodeURIComponent(normalized)}/reviewers`
+          const schema = Schema.Array(ReviewerListItem)
+          return yield* makeRequest(url, authHeader, 'GET', undefined, schema)
+        })
+
       const removeReviewer = (
         changeId: string,
         accountId: string,
@@ -674,6 +680,7 @@ export const GerritApiServiceLive: Layer.Layer<GerritApiService, never, ConfigSe
         getComments,
         getMessages,
         addReviewer,
+        getReviewers,
         listGroups,
         getGroup,
         getGroupDetail,

package/src/cli/commands/files.ts

@@ -0,0 +1,86 @@
+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'
+
+const MAGIC_FILES = new Set(['/COMMIT_MSG', '/MERGE_LIST', '/PATCHSET_LEVEL'])
+
+interface FilesOptions {
+  xml?: boolean
+  json?: boolean
+}
+
+export const filesCommand = (
+  changeId?: string,
+  options: FilesOptions = {},
+): Effect.Effect<void, never, GerritApiService> =>
+  Effect.gen(function* () {
+    const gerritApi = yield* GerritApiService
+    const resolvedChangeId = changeId || (yield* getChangeIdFromHead())
+
+    const filesRecord = yield* gerritApi.getFiles(resolvedChangeId)
+    const files = Object.entries(filesRecord)
+      .filter(([path]) => !MAGIC_FILES.has(path))
+      .map(([path, info]) => ({
+        path,
+        status: info.status ?? 'M',
+        lines_inserted: info.lines_inserted ?? 0,
+        lines_deleted: info.lines_deleted ?? 0,
+      }))
+
+    if (options.json) {
+      console.log(
+        JSON.stringify(
+          {
+            status: 'success',
+            change_id: resolvedChangeId,
+            files,
+          },
+          null,
+          2,
+        ),
+      )
+    } else if (options.xml) {
+      console.log(`<?xml version="1.0" encoding="UTF-8"?>`)
+      console.log(`<files_result>`)
+      console.log(`  <status>success</status>`)
+      console.log(`  <change_id><![CDATA[${sanitizeCDATA(resolvedChangeId)}]]></change_id>`)
+      console.log(`  <files>`)
+      for (const file of files) {
+        console.log(`    <file>`)
+        console.log(`      <path><![CDATA[${sanitizeCDATA(file.path)}]]></path>`)
+        console.log(`      <status>${escapeXML(file.status)}</status>`)
+        console.log(`      <lines_inserted>${file.lines_inserted}</lines_inserted>`)
+        console.log(`      <lines_deleted>${file.lines_deleted}</lines_deleted>`)
+        console.log(`    </file>`)
+      }
+      console.log(`  </files>`)
+      console.log(`</files_result>`)
+    } else {
+      for (const file of files) {
+        console.log(`${file.status} ${file.path}`)
+      }
+    }
+  }).pipe(
+    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.json) {
+          console.log(JSON.stringify({ status: 'error', error: errorMessage }, null, 2))
+        } else if (options.xml) {
+          console.log(`<?xml version="1.0" encoding="UTF-8"?>`)
+          console.log(`<files_result>`)
+          console.log(`  <status>error</status>`)
+          console.log(`  <error><![CDATA[${sanitizeCDATA(errorMessage)}]]></error>`)
+          console.log(`</files_result>`)
+        } else {
+          console.error(`✗ Error: ${errorMessage}`)
+        }
+        process.exit(1)
+      }),
+    ),
+  )

package/src/cli/commands/reviewers.ts

@@ -0,0 +1,95 @@
+import { Effect } from 'effect'
+import { type ApiError, GerritApiService } from '@/api/gerrit'
+import { GitError, NoChangeIdError, getChangeIdFromHead } from '@/utils/git-commit'
+import { sanitizeCDATA } from '@/utils/shell-safety'
+import type { ReviewerListItem } from '@/schemas/reviewer'
+
+interface ReviewersOptions {
+  xml?: boolean
+  json?: boolean
+}
+
+function formatReviewer(r: ReviewerListItem): string {
+  const name =
+    r.name ?? r.username ?? (r._account_id !== undefined ? `#${r._account_id}` : undefined)
+  if (name !== undefined) return r.email ? `${name} <${r.email}>` : name
+  return r.email ?? 'unknown'
+}
+
+export const reviewersCommand = (
+  changeId?: string,
+  options: ReviewersOptions = {},
+): Effect.Effect<void, never, GerritApiService> =>
+  Effect.gen(function* () {
+    const gerritApi = yield* GerritApiService
+    const resolvedChangeId = changeId || (yield* getChangeIdFromHead())
+
+    const reviewers = yield* gerritApi.getReviewers(resolvedChangeId)
+
+    if (options.json) {
+      console.log(
+        JSON.stringify(
+          {
+            status: 'success',
+            change_id: resolvedChangeId,
+            reviewers: reviewers.map((r) => ({
+              ...(r._account_id !== undefined ? { account_id: r._account_id } : {}),
+              name: r.name,
+              email: r.email,
+              username: r.username,
+            })),
+          },
+          null,
+          2,
+        ),
+      )
+    } else if (options.xml) {
+      console.log(`<?xml version="1.0" encoding="UTF-8"?>`)
+      console.log(`<reviewers_result>`)
+      console.log(`  <status>success</status>`)
+      console.log(`  <change_id><![CDATA[${sanitizeCDATA(resolvedChangeId)}]]></change_id>`)
+      console.log(`  <reviewers>`)
+      for (const r of reviewers) {
+        console.log(`    <reviewer>`)
+        if (r._account_id !== undefined)
+          console.log(`      <account_id>${r._account_id}</account_id>`)
+        if (r.name) console.log(`      <name><![CDATA[${sanitizeCDATA(r.name)}]]></name>`)
+        if (r.email) console.log(`      <email><![CDATA[${sanitizeCDATA(r.email)}]]></email>`)
+        if (r.username)
+          console.log(`      <username><![CDATA[${sanitizeCDATA(r.username)}]]></username>`)
+        console.log(`    </reviewer>`)
+      }
+      console.log(`  </reviewers>`)
+      console.log(`</reviewers_result>`)
+    } else {
+      if (reviewers.length === 0) {
+        console.log('No reviewers')
+      } else {
+        for (const r of reviewers) {
+          console.log(formatReviewer(r))
+        }
+      }
+    }
+  }).pipe(
+    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.json) {
+          console.log(JSON.stringify({ status: 'error', error: errorMessage }, null, 2))
+        } else if (options.xml) {
+          console.log(`<?xml version="1.0" encoding="UTF-8"?>`)
+          console.log(`<reviewers_result>`)
+          console.log(`  <status>error</status>`)
+          console.log(`  <error><![CDATA[${sanitizeCDATA(errorMessage)}]]></error>`)
+          console.log(`</reviewers_result>`)
+        } else {
+          console.error(`✗ Error: ${errorMessage}`)
+        }
+        process.exit(1)
+      }),
+    ),
+  )

package/src/cli/register-commands.ts

@@ -28,6 +28,8 @@ import { workspaceCommand } from './commands/workspace'
 import { sanitizeCDATA } from '@/utils/shell-safety'
 import { registerGroupCommands } from './register-group-commands'
 import { registerReviewerCommands } from './register-reviewer-commands'
+import { filesCommand } from './commands/files'
+import { reviewersCommand } from './commands/reviewers'
 
 // Helper function to output error in plain text, JSON, or XML format
 function outputError(
@@ -578,6 +580,44 @@ Note:
       }
     })
 
+  // files command
+  program
+    .command('files [change-id]')
+    .description(
+      'List files changed in a Gerrit change (auto-detects from HEAD commit if not specified)',
+    )
+    .option('--xml', 'XML output for LLM consumption')
+    .option('--json', 'JSON output for programmatic consumption')
+    .action(async (changeId, options) => {
+      await executeEffect(
+        filesCommand(changeId, options).pipe(
+          Effect.provide(GerritApiServiceLive),
+          Effect.provide(ConfigServiceLive),
+        ),
+        options,
+        'files_result',
+      )
+    })
+
+  // reviewers command
+  program
+    .command('reviewers [change-id]')
+    .description(
+      'List reviewers on a Gerrit change (auto-detects from HEAD commit if not specified)',
+    )
+    .option('--xml', 'XML output for LLM consumption')
+    .option('--json', 'JSON output for programmatic consumption')
+    .action(async (changeId, options) => {
+      await executeEffect(
+        reviewersCommand(changeId, options).pipe(
+          Effect.provide(GerritApiServiceLive),
+          Effect.provide(ConfigServiceLive),
+        ),
+        options,
+        'reviewers_result',
+      )
+    })
+
   // checkout command
   program
     .command('checkout <change-id>')

package/src/schemas/gerrit.ts

@@ -570,6 +570,8 @@ const ReviewerAccountInfo = Schema.Struct({
   username: Schema.optional(Schema.String),
 })
 
+export type { ReviewerListItem } from './reviewer'
+
 export const ReviewerResult: Schema.Schema<{
   readonly input: string
   readonly reviewers?: ReadonlyArray<{

package/src/schemas/reviewer.ts

@@ -0,0 +1,16 @@
+import { Schema } from '@effect/schema'
+
+export const ReviewerListItem: Schema.Schema<{
+  readonly _account_id?: number
+  readonly name?: string
+  readonly email?: string
+  readonly username?: string
+  readonly approvals?: { readonly [x: string]: string }
+}> = Schema.Struct({
+  _account_id: Schema.optional(Schema.Number),
+  name: Schema.optional(Schema.String),
+  email: Schema.optional(Schema.String),
+  username: Schema.optional(Schema.String),
+  approvals: Schema.optional(Schema.Record({ key: Schema.String, value: Schema.String })),
+})
+export type ReviewerListItem = Schema.Schema.Type<typeof ReviewerListItem>

package/tests/files.test.ts

@@ -0,0 +1,223 @@
+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 { filesCommand } from '@/cli/commands/files'
+import { ConfigService } from '@/services/config'
+import { createMockConfigService } from './helpers/config-mock'
+
+const mockFilesResponse = {
+  '/COMMIT_MSG': { status: 'A' as const, lines_inserted: 10 },
+  'src/foo.ts': { status: 'M' as const, lines_inserted: 5, lines_deleted: 2 },
+  'src/bar.ts': { status: 'A' as const, lines_inserted: 20 },
+  'src/old.ts': { status: 'D' as const, lines_deleted: 30 },
+}
+
+const server = setupServer(
+  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('files command', () => {
+  let mockConsoleLog: ReturnType<typeof mock>
+  let mockConsoleError: ReturnType<typeof mock>
+  let mockProcessExit: ReturnType<typeof mock>
+
+  beforeAll(() => {
+    server.listen({ onUnhandledRequest: 'bypass' })
+  })
+
+  afterAll(() => {
+    server.close()
+  })
+
+  beforeEach(() => {
+    mockConsoleLog = mock(() => {})
+    mockConsoleError = mock(() => {})
+    mockProcessExit = mock(() => {})
+    console.log = mockConsoleLog
+    console.error = mockConsoleError
+    process.exit = mockProcessExit as unknown as typeof process.exit
+  })
+
+  afterEach(() => {
+    server.resetHandlers()
+  })
+
+  it('should list changed files with plain output', async () => {
+    server.use(
+      http.get('*/a/changes/12345/revisions/current/files', () => {
+        return HttpResponse.text(`)]}'\n${JSON.stringify(mockFilesResponse)}`)
+      }),
+    )
+
+    const mockConfigLayer = Layer.succeed(ConfigService, createMockConfigService())
+    const program = filesCommand('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).not.toContain('/COMMIT_MSG')
+    expect(output).toContain('M src/foo.ts')
+    expect(output).toContain('A src/bar.ts')
+    expect(output).toContain('D src/old.ts')
+  })
+
+  it('should output JSON format', async () => {
+    server.use(
+      http.get('*/a/changes/12345/revisions/current/files', () => {
+        return HttpResponse.text(`)]}'\n${JSON.stringify(mockFilesResponse)}`)
+      }),
+    )
+
+    const mockConfigLayer = Layer.succeed(ConfigService, createMockConfigService())
+    const program = filesCommand('12345', { json: true }).pipe(
+      Effect.provide(GerritApiServiceLive),
+      Effect.provide(mockConfigLayer),
+    )
+
+    await Effect.runPromise(program)
+
+    const output = mockConsoleLog.mock.calls.map((call) => call[0]).join('\n')
+    const parsed = JSON.parse(output) as { status: string; change_id: string; files: unknown[] }
+    expect(parsed.status).toBe('success')
+    expect(parsed.change_id).toBe('12345')
+    expect(parsed.files).toBeArray()
+    const paths = (parsed.files as Array<{ path: string }>).map((f) => f.path)
+    expect(paths).not.toContain('/COMMIT_MSG')
+    expect(paths).toContain('src/foo.ts')
+  })
+
+  it('should output XML format', async () => {
+    server.use(
+      http.get('*/a/changes/12345/revisions/current/files', () => {
+        return HttpResponse.text(`)]}'\n${JSON.stringify(mockFilesResponse)}`)
+      }),
+    )
+
+    const mockConfigLayer = Layer.succeed(ConfigService, createMockConfigService())
+    const program = filesCommand('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('<?xml version="1.0" encoding="UTF-8"?>')
+    expect(output).toContain('<files_result>')
+    expect(output).toContain('<status>success</status>')
+    expect(output).toContain('<change_id><![CDATA[12345]]></change_id>')
+    expect(output).toContain('<path><![CDATA[src/foo.ts]]></path>')
+    expect(output).not.toContain('/COMMIT_MSG')
+    expect(output).toContain('</files_result>')
+  })
+
+  it('should handle empty files response (only magic files)', async () => {
+    server.use(
+      http.get('*/a/changes/12345/revisions/current/files', () => {
+        return HttpResponse.text(`)]}'\n${JSON.stringify({ '/COMMIT_MSG': { status: 'A' } })}`)
+      }),
+    )
+
+    const mockConfigLayer = Layer.succeed(ConfigService, createMockConfigService())
+    const program = filesCommand('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).not.toContain('/COMMIT_MSG')
+  })
+
+  it('should exit 1 on API error', async () => {
+    server.use(
+      http.get('*/a/changes/99999/revisions/current/files', () => {
+        return HttpResponse.text('Not Found', { status: 404 })
+      }),
+    )
+
+    const mockConfigLayer = Layer.succeed(ConfigService, createMockConfigService())
+    const program = filesCommand('99999', {}).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('Error:')
+    expect(mockProcessExit.mock.calls[0][0]).toBe(1)
+  })
+
+  it('should exit 1 and output XML on API error with --xml', async () => {
+    server.use(
+      http.get('*/a/changes/99999/revisions/current/files', () => {
+        return HttpResponse.text('Not Found', { status: 404 })
+      }),
+    )
+
+    const mockConfigLayer = Layer.succeed(ConfigService, createMockConfigService())
+    const program = filesCommand('99999', { 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('<files_result>')
+    expect(output).toContain('<status>error</status>')
+    expect(output).toContain('</files_result>')
+    expect(mockProcessExit.mock.calls[0][0]).toBe(1)
+  })
+
+  it('should exit 1 and output JSON on API error with --json', async () => {
+    server.use(
+      http.get('*/a/changes/99999/revisions/current/files', () => {
+        return HttpResponse.text('Not Found', { status: 404 })
+      }),
+    )
+
+    const mockConfigLayer = Layer.succeed(ConfigService, createMockConfigService())
+    const program = filesCommand('99999', { json: true }).pipe(
+      Effect.provide(GerritApiServiceLive),
+      Effect.provide(mockConfigLayer),
+    )
+
+    await Effect.runPromise(program)
+
+    const output = mockConsoleLog.mock.calls.map((call) => call[0]).join('\n')
+    const parsed = JSON.parse(output) as { status: string; error: string }
+    expect(parsed.status).toBe('error')
+    expect(typeof parsed.error).toBe('string')
+    expect(parsed.error.length).toBeGreaterThan(0)
+    expect(mockProcessExit.mock.calls[0][0]).toBe(1)
+  })
+
+  it('should exit 1 when no change-id and HEAD has no Change-Id', async () => {
+    const mockConfigLayer = Layer.succeed(ConfigService, createMockConfigService())
+    const program = filesCommand(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('Error:')
+    expect(errorOutput).toContain('No Change-ID found in HEAD commit')
+    expect(mockProcessExit.mock.calls[0][0]).toBe(1)
+  })
+})

package/tests/reviewers.test.ts

@@ -0,0 +1,259 @@
+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 { reviewersCommand } from '@/cli/commands/reviewers'
+import { ConfigService } from '@/services/config'
+import { createMockConfigService } from './helpers/config-mock'
+
+const mockReviewersResponse = [
+  {
+    _account_id: 1001,
+    name: 'Alice Smith',
+    email: 'alice@example.com',
+    username: 'alice',
+    approvals: { 'Code-Review': '0' },
+  },
+  {
+    _account_id: 1002,
+    name: 'Bob Jones',
+    email: 'bob@example.com',
+    username: 'bob',
+    approvals: { 'Code-Review': '+1' },
+  },
+]
+
+const server = setupServer(
+  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('reviewers command', () => {
+  let mockConsoleLog: ReturnType<typeof mock>
+  let mockConsoleError: ReturnType<typeof mock>
+  let mockProcessExit: ReturnType<typeof mock>
+
+  beforeAll(() => {
+    server.listen({ onUnhandledRequest: 'bypass' })
+  })
+
+  afterAll(() => {
+    server.close()
+  })
+
+  beforeEach(() => {
+    mockConsoleLog = mock(() => {})
+    mockConsoleError = mock(() => {})
+    mockProcessExit = mock(() => {})
+    console.log = mockConsoleLog
+    console.error = mockConsoleError
+    process.exit = mockProcessExit as unknown as typeof process.exit
+  })
+
+  afterEach(() => {
+    server.resetHandlers()
+  })
+
+  it('should list reviewers with plain output', async () => {
+    server.use(
+      http.get('*/a/changes/12345/reviewers', () => {
+        return HttpResponse.text(`)]}'\n${JSON.stringify(mockReviewersResponse)}`)
+      }),
+    )
+
+    const mockConfigLayer = Layer.succeed(ConfigService, createMockConfigService())
+    const program = reviewersCommand('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('Alice Smith')
+    expect(output).toContain('alice@example.com')
+    expect(output).toContain('Bob Jones')
+    expect(output).toContain('bob@example.com')
+  })
+
+  it('should handle email-only reviewer (no _account_id, no name)', async () => {
+    const emailOnlyReviewer = [{ email: 'ext@external.com', approvals: {} }]
+    server.use(
+      http.get('*/a/changes/12345/reviewers', () => {
+        return HttpResponse.text(`)]}'\n${JSON.stringify(emailOnlyReviewer)}`)
+      }),
+    )
+
+    const mockConfigLayer = Layer.succeed(ConfigService, createMockConfigService())
+    const program = reviewersCommand('12345', {}).pipe(
+      Effect.provide(GerritApiServiceLive),
+      Effect.provide(mockConfigLayer),
+    )
+
+    await Effect.runPromise(program)
+
+    const lines = mockConsoleLog.mock.calls.map((call) => call[0] as string)
+    expect(lines).toContain('ext@external.com')
+    // Must not produce "ext@external.com <ext@external.com>"
+    expect(lines.join('\n')).not.toContain('ext@external.com <ext@external.com>')
+  })
+
+  it('should output JSON format', async () => {
+    server.use(
+      http.get('*/a/changes/12345/reviewers', () => {
+        return HttpResponse.text(`)]}'\n${JSON.stringify(mockReviewersResponse)}`)
+      }),
+    )
+
+    const mockConfigLayer = Layer.succeed(ConfigService, createMockConfigService())
+    const program = reviewersCommand('12345', { json: true }).pipe(
+      Effect.provide(GerritApiServiceLive),
+      Effect.provide(mockConfigLayer),
+    )
+
+    await Effect.runPromise(program)
+
+    const output = mockConsoleLog.mock.calls.map((call) => call[0]).join('\n')
+    const parsed = JSON.parse(output) as {
+      status: string
+      change_id: string
+      reviewers: Array<{ account_id?: number; name?: string; email?: string }>
+    }
+    expect(parsed.status).toBe('success')
+    expect(parsed.change_id).toBe('12345')
+    expect(parsed.reviewers).toBeArray()
+    expect(parsed.reviewers.length).toBe(2)
+    expect(parsed.reviewers[0].name).toBe('Alice Smith')
+    expect(parsed.reviewers[1].email).toBe('bob@example.com')
+  })
+
+  it('should output XML format', async () => {
+    server.use(
+      http.get('*/a/changes/12345/reviewers', () => {
+        return HttpResponse.text(`)]}'\n${JSON.stringify(mockReviewersResponse)}`)
+      }),
+    )
+
+    const mockConfigLayer = Layer.succeed(ConfigService, createMockConfigService())
+    const program = reviewersCommand('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('<?xml version="1.0" encoding="UTF-8"?>')
+    expect(output).toContain('<reviewers_result>')
+    expect(output).toContain('<status>success</status>')
+    expect(output).toContain('<change_id><![CDATA[12345]]></change_id>')
+    expect(output).toContain('<name><![CDATA[Alice Smith]]></name>')
+    expect(output).toContain('<email><![CDATA[bob@example.com]]></email>')
+    expect(output).toContain('</reviewers_result>')
+  })
+
+  it('should handle empty reviewers list', async () => {
+    server.use(
+      http.get('*/a/changes/12345/reviewers', () => {
+        return HttpResponse.text(`)]}'\n${JSON.stringify([])}`)
+      }),
+    )
+
+    const mockConfigLayer = Layer.succeed(ConfigService, createMockConfigService())
+    const program = reviewersCommand('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('No reviewers')
+  })
+
+  it('should exit 1 on API error', async () => {
+    server.use(
+      http.get('*/a/changes/99999/reviewers', () => {
+        return HttpResponse.text('Not Found', { status: 404 })
+      }),
+    )
+
+    const mockConfigLayer = Layer.succeed(ConfigService, createMockConfigService())
+    const program = reviewersCommand('99999', {}).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('Error:')
+    expect(mockProcessExit.mock.calls[0][0]).toBe(1)
+  })
+
+  it('should exit 1 and output XML on API error with --xml', async () => {
+    server.use(
+      http.get('*/a/changes/99999/reviewers', () => {
+        return HttpResponse.text('Forbidden', { status: 403 })
+      }),
+    )
+
+    const mockConfigLayer = Layer.succeed(ConfigService, createMockConfigService())
+    const program = reviewersCommand('99999', { 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('<reviewers_result>')
+    expect(output).toContain('<status>error</status>')
+    expect(output).toContain('</reviewers_result>')
+    expect(mockProcessExit.mock.calls[0][0]).toBe(1)
+  })
+
+  it('should exit 1 and output JSON on API error with --json', async () => {
+    server.use(
+      http.get('*/a/changes/99999/reviewers', () => {
+        return HttpResponse.text('Not Found', { status: 404 })
+      }),
+    )
+
+    const mockConfigLayer = Layer.succeed(ConfigService, createMockConfigService())
+    const program = reviewersCommand('99999', { json: true }).pipe(
+      Effect.provide(GerritApiServiceLive),
+      Effect.provide(mockConfigLayer),
+    )
+
+    await Effect.runPromise(program)
+
+    const output = mockConsoleLog.mock.calls.map((call) => call[0]).join('\n')
+    const parsed = JSON.parse(output) as { status: string; error: string }
+    expect(parsed.status).toBe('error')
+    expect(typeof parsed.error).toBe('string')
+    expect(parsed.error.length).toBeGreaterThan(0)
+    expect(mockProcessExit.mock.calls[0][0]).toBe(1)
+  })
+
+  it('should exit 1 when no change-id and HEAD has no Change-Id', async () => {
+    const mockConfigLayer = Layer.succeed(ConfigService, createMockConfigService())
+    const program = reviewersCommand(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('Error:')
+    expect(errorOutput).toContain('No Change-ID found in HEAD commit')
+    expect(mockProcessExit.mock.calls[0][0]).toBe(1)
+  })
+})