@aaronshaf/ger 0.2.2 → 0.2.4

package/package.json

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

package/src/cli/commands/show.ts

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

package/tests/show-auto-detect.test.ts

@@ -75,6 +75,7 @@ ${JSON.stringify(mockChange)}`)
 
 let capturedLogs: string[] = []
 let capturedErrors: string[] = []
+let capturedStdout: string[] = []
 
 const mockConsoleLog = mock((...args: any[]) => {
   capturedLogs.push(args.join(' '))
@@ -83,8 +84,19 @@ const mockConsoleError = mock((...args: any[]) => {
   capturedErrors.push(args.join(' '))
 })
 
+// Mock process.stdout.write to capture JSON/XML output and handle callbacks
+const mockStdoutWrite = mock((chunk: any, callback?: any) => {
+  capturedStdout.push(String(chunk))
+  // Call the callback synchronously if provided
+  if (typeof callback === 'function') {
+    callback()
+  }
+  return true
+})
+
 const originalConsoleLog = console.log
 const originalConsoleError = console.error
+const originalStdoutWrite = process.stdout.write
 
 let spawnSpy: ReturnType<typeof spyOn>
 
@@ -94,20 +106,26 @@ beforeAll(() => {
   console.log = mockConsoleLog
   // @ts-ignore
   console.error = mockConsoleError
+  // @ts-ignore
+  process.stdout.write = mockStdoutWrite
 })
 
 afterAll(() => {
   server.close()
   console.log = originalConsoleLog
   console.error = originalConsoleError
+  // @ts-ignore
+  process.stdout.write = originalStdoutWrite
 })
 
 afterEach(() => {
   server.resetHandlers()
   mockConsoleLog.mockClear()
   mockConsoleError.mockClear()
+  mockStdoutWrite.mockClear()
   capturedLogs = []
   capturedErrors = []
+  capturedStdout = []
 
   if (spawnSpy) {
     spawnSpy.mockRestore()
@@ -184,7 +202,7 @@ Change-Id: If5a3ae8cb5a107e187447802358417f311d0c4b1`
 
     await resultPromise
 
-    const output = capturedLogs.join('\n')
+    const output = capturedStdout.join('')
     expect(output).toContain('<?xml version="1.0" encoding="UTF-8"?>')
     expect(output).toContain('<show_result>')
     expect(output).toContain('<status>success</status>')
@@ -297,7 +315,7 @@ This commit has no Change-ID footer.`
 
     await resultPromise
 
-    const output = capturedLogs.join('\n')
+    const output = capturedStdout.join('')
     expect(output).toContain('<?xml version="1.0" encoding="UTF-8"?>')
     expect(output).toContain('<show_result>')
     expect(output).toContain('<status>error</status>')

package/tests/show.test.ts

@@ -27,6 +27,7 @@ const server = setupServer(
 // Store captured output
 let capturedLogs: string[] = []
 let capturedErrors: string[] = []
+let capturedStdout: string[] = []
 
 // Mock console.log and console.error
 const mockConsoleLog = mock((...args: any[]) => {
@@ -36,9 +37,20 @@ const mockConsoleError = mock((...args: any[]) => {
   capturedErrors.push(args.join(' '))
 })
 
-// Store original console methods
+// Mock process.stdout.write to capture JSON output and handle callbacks
+const mockStdoutWrite = mock((chunk: any, callback?: any) => {
+  capturedStdout.push(String(chunk))
+  // Call the callback synchronously if provided
+  if (typeof callback === 'function') {
+    callback()
+  }
+  return true
+})
+
+// Store original methods
 const originalConsoleLog = console.log
 const originalConsoleError = console.error
+const originalStdoutWrite = process.stdout.write
 
 beforeAll(() => {
   server.listen({ onUnhandledRequest: 'bypass' })
@@ -46,20 +58,26 @@ beforeAll(() => {
   console.log = mockConsoleLog
   // @ts-ignore
   console.error = mockConsoleError
+  // @ts-ignore
+  process.stdout.write = mockStdoutWrite
 })
 
 afterAll(() => {
   server.close()
   console.log = originalConsoleLog
   console.error = originalConsoleError
+  // @ts-ignore
+  process.stdout.write = originalStdoutWrite
 })
 
 afterEach(() => {
   server.resetHandlers()
   mockConsoleLog.mockClear()
   mockConsoleError.mockClear()
+  mockStdoutWrite.mockClear()
   capturedLogs = []
   capturedErrors = []
+  capturedStdout = []
 })
 
 describe('show command', () => {
@@ -201,7 +219,7 @@ describe('show command', () => {
 
     await Effect.runPromise(program)
 
-    const output = capturedLogs.join('\n')
+    const output = capturedStdout.join('')
 
     expect(output).toContain('<?xml version="1.0" encoding="UTF-8"?>')
     expect(output).toContain('<show_result>')
@@ -258,7 +276,7 @@ describe('show command', () => {
 
     await Effect.runPromise(program)
 
-    const output = capturedLogs.join('\n')
+    const output = capturedStdout.join('')
 
     expect(output).toContain('<?xml version="1.0" encoding="UTF-8"?>')
     expect(output).toContain('<show_result>')
@@ -301,7 +319,7 @@ describe('show command', () => {
 
     await Effect.runPromise(program)
 
-    const output = capturedLogs.join('\n')
+    const output = capturedStdout.join('')
 
     expect(output).toContain('<subject><![CDATA[Fix "quotes" & <tags> in auth]]></subject>')
     expect(output).toContain('<branch>feature/fix&amp;improve</branch>')
@@ -450,7 +468,7 @@ describe('show command', () => {
 
     await Effect.runPromise(program)
 
-    const output = capturedLogs.join('\n')
+    const output = capturedStdout.join('')
 
     // Parse JSON to verify it's valid
     const parsed = JSON.parse(output)
@@ -495,7 +513,7 @@ describe('show command', () => {
 
     await Effect.runPromise(program)
 
-    const output = capturedLogs.join('\n')
+    const output = capturedStdout.join('')
 
     // Parse JSON to verify it's valid
     const parsed = JSON.parse(output)
@@ -516,7 +534,7 @@ describe('show command', () => {
 
     await Effect.runPromise(program)
 
-    const output = capturedLogs.join('\n')
+    const output = capturedStdout.join('')
 
     // Extract comment sections to verify order
     const commentMatches = output.matchAll(
@@ -581,7 +599,7 @@ describe('show command', () => {
 
     await Effect.runPromise(program)
 
-    const output = capturedLogs.join('\n')
+    const output = capturedStdout.join('')
     const parsed = JSON.parse(output)
 
     expect(parsed.messages).toBeDefined()
@@ -592,4 +610,204 @@ describe('show command', () => {
     expect(parsed.messages[0].author.name).toBe('Jenkins Bot')
     expect(parsed.messages[0].revision).toBe(2)
   })
+
+  test('should handle large JSON output without truncation', async () => {
+    // Create a large diff to simulate output > 64KB
+    const largeDiff = '--- a/large-file.js\n+++ b/large-file.js\n' + 'x'.repeat(100000)
+
+    const mockChange = generateMockChange({
+      _number: 12345,
+      subject: 'Large change with extensive diff',
+    })
+
+    // Create many comments to increase JSON size
+    const manyComments: Record<string, any[]> = {
+      'src/file.js': Array.from({ length: 100 }, (_, i) => ({
+        id: `comment${i}`,
+        path: 'src/file.js',
+        line: i + 1,
+        message: `Comment ${i}: ${'a'.repeat(500)}`, // Make comments substantial
+        author: {
+          name: 'Reviewer',
+          email: 'reviewer@example.com',
+        },
+        updated: '2024-01-15 11:30:00.000000000',
+        unresolved: false,
+      })),
+    }
+
+    server.use(
+      http.get('*/a/changes/:changeId', () => {
+        return HttpResponse.text(`)]}'\n${JSON.stringify(mockChange)}`)
+      }),
+      http.get('*/a/changes/:changeId/revisions/current/patch', () => {
+        return HttpResponse.text(btoa(largeDiff))
+      }),
+      http.get('*/a/changes/:changeId/revisions/current/comments', () => {
+        return HttpResponse.text(`)]}'\n${JSON.stringify(manyComments)}`)
+      }),
+      http.get('*/a/changes/:changeId/revisions/current/files/:fileName/diff', () => {
+        return HttpResponse.text('context')
+      }),
+    )
+
+    const mockConfigLayer = createMockConfigLayer()
+    const program = showCommand('12345', { json: true }).pipe(
+      Effect.provide(GerritApiServiceLive),
+      Effect.provide(mockConfigLayer),
+    )
+
+    await Effect.runPromise(program)
+
+    const output = capturedStdout.join('')
+
+    // Verify output is larger than 64KB (the previous truncation point)
+    expect(output.length).toBeGreaterThan(65536)
+
+    // Verify JSON is valid and complete
+    const parsed = JSON.parse(output)
+    expect(parsed.status).toBe('success')
+    expect(parsed.diff).toContain('x'.repeat(100000))
+    expect(parsed.comments.length).toBe(100)
+
+    // Verify last comment is present (proves no truncation)
+    const lastComment = parsed.comments[parsed.comments.length - 1]
+    expect(lastComment.message).toContain('Comment 99')
+  })
+
+  test('should handle stdout drain event when buffer is full', async () => {
+    setupMockHandlers()
+
+    // Store original stdout.write
+    const originalStdoutWrite = process.stdout.write
+
+    let drainCallback: (() => void) | null = null
+    let errorCallback: ((err: Error) => void) | null = null
+    let writeCallbackFn: ((err?: Error) => void) | null = null
+
+    // Mock stdout.write to simulate full buffer
+    const mockWrite = mock((chunk: any, callback?: any) => {
+      capturedStdout.push(String(chunk))
+      writeCallbackFn = callback
+      // Return false to simulate full buffer
+      return false
+    })
+
+    // Mock stdout.once to capture drain and error listeners
+    const mockOnce = mock((event: string, callback: any) => {
+      if (event === 'drain') {
+        drainCallback = callback
+        // Simulate drain event after a short delay
+        setTimeout(() => {
+          if (drainCallback) {
+            drainCallback()
+            if (writeCallbackFn) {
+              writeCallbackFn()
+            }
+          }
+        }, 10)
+      } else if (event === 'error') {
+        errorCallback = callback
+      }
+      return process.stdout
+    })
+
+    // Apply mocks
+    // @ts-ignore
+    process.stdout.write = mockWrite
+    // @ts-ignore
+    process.stdout.once = mockOnce
+
+    const mockConfigLayer = createMockConfigLayer()
+    const program = showCommand('12345', { json: true }).pipe(
+      Effect.provide(GerritApiServiceLive),
+      Effect.provide(mockConfigLayer),
+    )
+
+    await Effect.runPromise(program)
+
+    // Restore original stdout.write
+    // @ts-ignore
+    process.stdout.write = originalStdoutWrite
+
+    // Verify that write returned false (buffer full)
+    expect(mockWrite).toHaveBeenCalled()
+
+    // Verify that drain listener was registered
+    expect(mockOnce).toHaveBeenCalledWith('drain', expect.any(Function))
+
+    // Verify that error listener was registered for robustness
+    expect(mockOnce).toHaveBeenCalledWith('error', expect.any(Function))
+
+    // Verify output is still valid JSON despite drain handling
+    const output = capturedStdout.join('')
+    const parsed = JSON.parse(output)
+    expect(parsed.status).toBe('success')
+    expect(parsed.change.id).toBe('I123abc456def')
+  })
+
+  test('should handle large XML output without truncation', async () => {
+    // Create a large diff to simulate output > 64KB
+    const largeDiff = '--- a/large-file.js\n+++ b/large-file.js\n' + 'x'.repeat(100000)
+
+    const mockChange = generateMockChange({
+      _number: 12345,
+      subject: 'Large change with extensive diff',
+    })
+
+    // Create many comments to increase XML size
+    const manyComments: Record<string, any[]> = {
+      'src/file.js': Array.from({ length: 100 }, (_, i) => ({
+        id: `comment${i}`,
+        path: 'src/file.js',
+        line: i + 1,
+        message: `Comment ${i}: ${'a'.repeat(500)}`,
+        author: {
+          name: 'Reviewer',
+          email: 'reviewer@example.com',
+        },
+        updated: '2024-01-15 11:30:00.000000000',
+        unresolved: false,
+      })),
+    }
+
+    server.use(
+      http.get('*/a/changes/:changeId', () => {
+        return HttpResponse.text(`)]}'\n${JSON.stringify(mockChange)}`)
+      }),
+      http.get('*/a/changes/:changeId/revisions/current/patch', () => {
+        return HttpResponse.text(btoa(largeDiff))
+      }),
+      http.get('*/a/changes/:changeId/revisions/current/comments', () => {
+        return HttpResponse.text(`)]}'\n${JSON.stringify(manyComments)}`)
+      }),
+      http.get('*/a/changes/:changeId/revisions/current/files/:fileName/diff', () => {
+        return HttpResponse.text('context')
+      }),
+    )
+
+    const mockConfigLayer = createMockConfigLayer()
+    const program = showCommand('12345', { xml: true }).pipe(
+      Effect.provide(GerritApiServiceLive),
+      Effect.provide(mockConfigLayer),
+    )
+
+    await Effect.runPromise(program)
+
+    const output = capturedStdout.join('')
+
+    // Verify output is larger than 64KB
+    expect(output.length).toBeGreaterThan(65536)
+
+    // Verify XML is valid and complete
+    expect(output).toContain('<?xml version="1.0" encoding="UTF-8"?>')
+    expect(output).toContain('<show_result>')
+    expect(output).toContain('<status>success</status>')
+    expect(output).toContain('x'.repeat(100000))
+    expect(output).toContain('<count>100</count>')
+    expect(output).toContain('</show_result>')
+
+    // Verify last comment is present (proves no truncation)
+    expect(output).toContain('Comment 99')
+  })
 })