fix(cli): @ menu with apostrophes, preserve input on dialogs, keep leading whitespace

Author: brandonkachen

cli/package.json

@@ -19,7 +19,7 @@
     "prebuild:agents": "bun run scripts/prebuild-agents.ts",
     "build:binary": "bun ./scripts/build-binary.ts codebuff $npm_package_version",
     "release": "bun run scripts/release.ts",
-    "test": "bun test",
+    "test": "NODE_ENV=production bun test",
     "test:tmux-poc": "bun run src/__tests__/tmux-poc.ts",
     "typecheck": "tsc --noEmit -p ."
   },

cli/src/components/tools/__tests__/run-terminal-command.test.ts

@@ -0,0 +1,188 @@
+import { describe, expect, test } from 'bun:test'
+
+import { parseTerminalOutput, RunTerminalCommandComponent } from '../run-terminal-command'
+
+import type { ToolBlock } from '../types'
+
+// Helper to create a mock tool block
+const createToolBlock = (
+  command: string,
+  output?: string,
+): ToolBlock & { toolName: 'run_terminal_command' } => ({
+  type: 'tool',
+  toolName: 'run_terminal_command',
+  toolCallId: 'test-tool-call-id',
+  input: { command },
+  output,
+})
+
+// Helper to create JSON output in the format the component expects
+const createJsonOutput = (stdout: string, stderr = ''): string => {
+  return JSON.stringify([
+    {
+      type: 'json',
+      value: {
+        command: 'test',
+        stdout,
+        stderr,
+        exitCode: 0,
+      },
+    },
+  ])
+}
+
+describe('RunTerminalCommandComponent', () => {
+  describe('render', () => {
+    test('returns content and collapsedPreview', () => {
+      const toolBlock = createToolBlock('ls -la', createJsonOutput('file1\nfile2'))
+      const mockTheme = {} as any
+      const mockOptions = {
+        availableWidth: 80,
+        indentationOffset: 0,
+        labelWidth: 10,
+      }
+
+      const result = RunTerminalCommandComponent.render(toolBlock, mockTheme, mockOptions)
+
+      expect(result).toBeDefined()
+      expect(result.content).toBeDefined()
+      expect(result.collapsedPreview).toBe('$ ls -la')
+    })
+
+    test('preserves leading whitespace in stdout (tree output)', () => {
+      // Simulate tree command output with leading spaces for indentation
+      const treeOutput = `├── src
+│   ├── index.ts
+│   └── utils
+│       └── helper.ts
+└── package.json`
+
+      const { output } = parseTerminalOutput(createJsonOutput(treeOutput))
+
+      expect(output).toBe(treeOutput)
+      // Verify leading characters are preserved (├ has no leading space, but indented lines do)
+      expect(output?.startsWith('├')).toBe(true)
+      expect(output).toContain('│   ├')
+      expect(output).toContain('│       └')
+    })
+
+    test('preserves leading spaces in table-like output', () => {
+      // Simulate output with leading spaces for alignment
+      const tableOutput = `  Name        Size     Modified
+  file1.txt   1.2KB    2024-01-15
+  file2.txt   3.4MB    2024-01-16`
+
+      const { output } = parseTerminalOutput(createJsonOutput(tableOutput))
+
+      expect(output).toBe(tableOutput)
+      // Verify leading spaces are preserved
+      expect(output?.startsWith('  ')).toBe(true)
+    })
+
+    test('preserves leading spaces in indented code output', () => {
+      // Simulate indented output like grep with context
+      const indentedOutput = `    function hello() {
+        console.log("world")
+    }`
+
+      const { output } = parseTerminalOutput(createJsonOutput(indentedOutput))
+
+      expect(output).toBe(indentedOutput)
+      expect(output?.startsWith('    ')).toBe(true)
+    })
+
+    test('removes trailing whitespace while preserving leading whitespace', () => {
+      const outputWithTrailing = '  leading preserved\ntrailing removed   \n\n'
+      const expectedOutput = '  leading preserved\ntrailing removed'
+
+      const { output } = parseTerminalOutput(createJsonOutput(outputWithTrailing))
+
+      expect(output).toBe(expectedOutput)
+      // Leading spaces preserved
+      expect(output?.startsWith('  ')).toBe(true)
+      // Trailing whitespace removed
+      expect(output?.endsWith('removed')).toBe(true)
+    })
+
+    test('handles raw string output (non-JSON) and preserves leading whitespace', () => {
+      const rawOutput = '    indented raw output'
+      const { output } = parseTerminalOutput(rawOutput)
+
+      expect(output).toBe(rawOutput)
+      expect(output?.startsWith('    ')).toBe(true)
+    })
+
+    test('handles combined stdout and stderr with leading whitespace', () => {
+      const stdout = '  stdout with leading space\n'
+      const stderr = '  stderr with leading space'
+
+      const { output } = parseTerminalOutput(
+        JSON.stringify([
+          {
+            type: 'json',
+            value: { stdout, stderr, exitCode: 0 },
+          },
+        ]),
+      )
+
+      expect(output).toContain('  stdout with leading space')
+      expect(output).toContain('  stderr with leading space')
+    })
+
+    test('handles output that is only whitespace', () => {
+      const whitespaceOnly = '   '
+      const { output } = parseTerminalOutput(createJsonOutput(whitespaceOnly))
+
+      // trimEnd() on whitespace-only string returns empty string, which becomes null
+      expect(output).toBe(null)
+    })
+
+    test('handles empty output', () => {
+      const { output } = parseTerminalOutput(createJsonOutput(''))
+
+      expect(output).toBe(null)
+    })
+  })
+
+  describe('parseTerminalOutput', () => {
+    test('handles error messages', () => {
+      const errorPayload = JSON.stringify([
+        {
+          type: 'json',
+          value: {
+            command: 'test',
+            errorMessage: 'Something went wrong',
+            stdout: '',
+            stderr: '',
+            exitCode: 1,
+          },
+        },
+      ])
+
+      const { output, startingCwd } = parseTerminalOutput(errorPayload)
+
+      expect(output).toBe('Error: Something went wrong')
+      expect(startingCwd).toBeUndefined()
+    })
+
+    test('extracts startingCwd when present', () => {
+      const payloadWithCwd = JSON.stringify([
+        {
+          type: 'json',
+          value: {
+            command: 'pwd',
+            stdout: '/project\n',
+            stderr: '',
+            exitCode: 0,
+            startingCwd: '/project',
+          },
+        },
+      ])
+
+      const { output, startingCwd } = parseTerminalOutput(payloadWithCwd)
+
+      expect(output).toBe('/project')
+      expect(startingCwd).toBe('/project')
+    })
+  })
+})

cli/src/components/tools/run-terminal-command.tsx

@@ -3,6 +3,44 @@ import { TerminalCommandDisplay } from '../terminal-command-display'
 
 import type { ToolRenderConfig } from './types'
 
+export interface ParsedTerminalOutput {
+  output: string | null
+  startingCwd?: string
+}
+
+/**
+ * Parse terminal command output from JSON or raw string format.
+ * Exported for testing.
+ */
+export const parseTerminalOutput = (rawOutput: string | undefined): ParsedTerminalOutput => {
+  if (!rawOutput) {
+    return { output: null }
+  }
+
+  try {
+    const parsed = JSON.parse(rawOutput)
+    // Handle array format [{ type: 'json', value: {...} }]
+    const value = Array.isArray(parsed) ? parsed[0]?.value : parsed
+    if (value) {
+      const startingCwd = value.startingCwd
+      // Handle error case
+      if (value.errorMessage) {
+        return { output: `Error: ${value.errorMessage}`, startingCwd }
+      }
+      // Combine stdout and stderr for display
+      // Use trimEnd() to preserve leading spaces (used for UI elements like trees/tables)
+      const stdout = value.stdout || ''
+      const stderr = value.stderr || ''
+      const output = (stdout + stderr).trimEnd() || null
+      return { output, startingCwd }
+    }
+    return { output: null }
+  } catch {
+    // If not JSON, use raw output (preserve leading spaces)
+    return { output: rawOutput.trimEnd() || null }
+  }
+}
+
 /**
  * UI component for run_terminal_command tool.
  * Displays the command in bold next to the bullet point,
@@ -19,31 +57,7 @@ export const RunTerminalCommandComponent = defineToolComponent({
         : ''
 
     // Extract output and startingCwd from tool result
-    let output: string | null = null
-    let startingCwd: string | undefined
-
-    if (toolBlock.output) {
-      try {
-        const parsed = JSON.parse(toolBlock.output)
-        // Handle array format [{ type: 'json', value: {...} }]
-        const value = Array.isArray(parsed) ? parsed[0]?.value : parsed
-        if (value) {
-          startingCwd = value.startingCwd
-          // Handle error case
-          if (value.errorMessage) {
-            output = `Error: ${value.errorMessage}`
-          } else {
-            // Combine stdout and stderr for display
-            const stdout = value.stdout || ''
-            const stderr = value.stderr || ''
-            output = (stdout + stderr).trim() || null
-          }
-        }
-      } catch {
-        // If not JSON, use raw output
-        output = toolBlock.output.trim() || null
-      }
-    }
+    const { output, startingCwd } = parseTerminalOutput(toolBlock.output)
 
     // Custom content component using shared TerminalCommandDisplay
     const content = (

cli/src/components/top-banner.tsx

@@ -42,13 +42,8 @@ const TOP_BANNER_REGISTRY: Record<NonNullable<TopBannerType>, BannerConfig> = {
     borderColorKey: 'warning',
     textColorKey: 'foreground',
     relatedInputMode: 'homeDir',
-    content: (
-      <>
-        You are currently in your home directory.
-        <br />
-        Select a project folder to get started, or choose "Start here".
-      </>
-    ),
+    content:
+      'You are currently in your home directory.\nSelect a project folder to get started, or choose "Start here".',
   },
   gitRoot: {
     borderColorKey: 'warning',