Merge origin/main into brandon/cli-themes

Resolved conflicts by accepting main's refactoring changes.
Main branch includes:
- Refactored hooks architecture (use-agent-initialization, use-auth-state, etc.)
- New tool components (diff-viewer, read-subtree, write-todos, etc.)
- UI improvements and constants
- Test additions

Our daemon improvements remain intact in theme-system.ts and related files.

🤖 Generated with [Claude Code](https://claude.com/claude-code)

Co-Authored-By: Claude <[email protected]>

Author: brandonkachen

bun.lock

@@ -287,7 +287,7 @@
     },
     "sdk": {
       "name": "@codebuff/sdk",
-      "version": "0.5.12",
+      "version": "0.6.1",
       "dependencies": {
         "@jitl/quickjs-wasmfile-release-sync": "0.31.0",
         "@vscode/tree-sitter-wasm": "0.1.4",

cli/src/__tests__/mocks/hover-toggle-controller.ts

@@ -0,0 +1,68 @@
+import { OPEN_DELAY_MS, CLOSE_DELAY_MS, REOPEN_SUPPRESS_MS } from '../../components/agent-mode-toggle'
+
+export const createHoverToggleControllerForTest = () => {
+  let isOpen = false
+  let reopenBlockedUntil = 0
+  let openTimeout: any = null
+  let closeTimeout: any = null
+
+  const clearOpenTimer = () => {
+    clearTimeout(openTimeout)
+    openTimeout = null
+  }
+
+  const clearCloseTimer = () => {
+    clearTimeout(closeTimeout)
+    closeTimeout = null
+  }
+
+  const clearAllTimers = () => {
+    clearOpenTimer()
+    clearCloseTimer()
+  }
+
+  const openNow = () => {
+    clearAllTimers()
+    isOpen = true
+  }
+
+  const closeNow = (suppressReopen = false) => {
+    clearAllTimers()
+    isOpen = false
+    if (suppressReopen) {
+      reopenBlockedUntil = Date.now() + REOPEN_SUPPRESS_MS
+    }
+  }
+
+  const scheduleOpen = () => {
+    if (isOpen) return
+    if (Date.now() < reopenBlockedUntil) return
+    clearOpenTimer()
+    openTimeout = setTimeout(() => {
+      openNow()
+    }, OPEN_DELAY_MS)
+  }
+
+  const scheduleClose = () => {
+    if (!isOpen) return
+    clearCloseTimer()
+    closeTimeout = setTimeout(() => {
+      isOpen = false
+      closeTimeout = null
+    }, CLOSE_DELAY_MS)
+  }
+
+  return {
+    get isOpen() {
+      return isOpen
+    },
+    openNow,
+    closeNow,
+    scheduleOpen,
+    scheduleClose,
+    clearOpenTimer,
+    clearCloseTimer,
+    clearAllTimers,
+  }
+}
+

cli/src/__tests__/unit/agent-mode-toggle.test.ts

@@ -0,0 +1,124 @@
+import { describe, test, expect, beforeEach, afterEach } from 'bun:test'
+
+import { buildExpandedSegments, resolveAgentModeClick, OPEN_DELAY_MS, CLOSE_DELAY_MS, REOPEN_SUPPRESS_MS } from '../../components/agent-mode-toggle'
+import { createHoverToggleControllerForTest } from '../mocks/hover-toggle-controller'
+
+import type { AgentMode } from '../../utils/constants'
+
+describe('AgentModeToggle - buildExpandedSegments', () => {
+  const modes: AgentMode[] = ['FAST', 'MAX', 'PLAN']
+
+  for (const mode of modes) {
+    test(`returns segments with active indicator for ${mode}`, () => {
+      const segs = buildExpandedSegments(mode)
+      // 3 mode options + 1 active indicator
+      expect(segs.length).toBe(4)
+
+      // Current mode is disabled among the choices
+      const current = segs.find((s) => s.id === mode)
+      expect(current?.disabled).toBe(true)
+
+      // Active indicator has expected id and flags
+      const active = segs.find((s) => s.id === `active-${mode}`)
+      expect(active).toBeTruthy()
+      expect(active?.isSelected).toBe(true)
+      expect(active?.defaultHighlighted).toBe(true)
+    })
+  }
+})
+
+describe('AgentModeToggle - resolveAgentModeClick', () => {
+  test('clicking active indicator returns closeActive', () => {
+    const action = resolveAgentModeClick('FAST', 'active-FAST', true)
+    expect(action).toEqual({ type: 'closeActive' })
+  })
+
+  test('with onSelectMode provided, clicking different mode selects it', () => {
+    const action = resolveAgentModeClick('FAST', 'MAX', true)
+    expect(action).toEqual({ type: 'selectMode', mode: 'MAX' })
+  })
+
+  test('without onSelectMode, clicking different mode toggles', () => {
+    const action = resolveAgentModeClick('FAST', 'PLAN', false)
+    expect(action).toEqual({ type: 'toggleMode', mode: 'PLAN' })
+  })
+})
+
+describe('useHoverToggle timing (controller)', () => {
+  let originalSetTimeout: typeof setTimeout
+  let originalClearTimeout: typeof clearTimeout
+  let originalNow: typeof Date.now
+
+  let timers: { id: number; ms: number; fn: Function; active: boolean }[]
+  let nextId: number
+
+  const runAll = () => {
+    for (const t of timers) {
+      if (t.active) t.fn()
+    }
+    timers = []
+  }
+
+  beforeEach(() => {
+    timers = []
+    nextId = 1
+    originalSetTimeout = setTimeout
+    originalClearTimeout = clearTimeout
+    originalNow = Date.now
+
+    let now = 1_000
+    Date.now = () => now
+    ;(Date.now as any).set = (v: number) => {
+      now = v
+    }
+
+    globalThis.setTimeout = ((fn: Function, ms?: number) => {
+      const id = nextId++
+      timers.push({ id, ms: Number(ms ?? 0), fn, active: true })
+      return id as any
+    }) as any
+
+    globalThis.clearTimeout = ((id?: any) => {
+      const rec = timers.find((t) => t.id === id)
+      if (rec) rec.active = false
+    }) as any
+  })
+
+  afterEach(() => {
+    globalThis.setTimeout = originalSetTimeout
+    globalThis.clearTimeout = originalClearTimeout
+    Date.now = originalNow
+  })
+
+  test('scheduleOpen waits OPEN_DELAY_MS then opens', () => {
+    const ctl = createHoverToggleControllerForTest()
+    expect(ctl.isOpen).toBe(false)
+    ctl.scheduleOpen()
+    expect(timers.length).toBe(1)
+    expect(timers[0].ms).toBe(OPEN_DELAY_MS)
+    runAll()
+    expect(ctl.isOpen).toBe(true)
+  })
+
+  test('scheduleClose waits CLOSE_DELAY_MS then closes', () => {
+    const ctl = createHoverToggleControllerForTest()
+    ctl.openNow()
+    expect(ctl.isOpen).toBe(true)
+    ctl.scheduleClose()
+    expect(timers.length).toBe(1)
+    expect(timers[0].ms).toBe(CLOSE_DELAY_MS)
+    runAll()
+    expect(ctl.isOpen).toBe(false)
+  })
+
+  test('closeNow(true) suppresses reopen until time passes', () => {
+    const ctl = createHoverToggleControllerForTest()
+    ctl.closeNow(true)
+    ctl.scheduleOpen()
+    expect(timers.length).toBe(0)
+    ;(Date.now as any).set(1_000 + REOPEN_SUPPRESS_MS + 1)
+    ctl.scheduleOpen()
+    expect(timers.length).toBe(1)
+    expect(timers[0].ms).toBe(OPEN_DELAY_MS)
+  })
+})

cli/src/__tests__/unit/segmented-control.test.ts

@@ -0,0 +1,147 @@
+import { describe, test, expect } from 'bun:test'
+import stringWidth from 'string-width'
+
+import {
+  type Segment,
+  processSegments,
+  type ProcessedSegment,
+} from '../../components/segmented-control'
+
+import type { ChatTheme } from '../../types/theme-system'
+
+const theme: ChatTheme = {
+  // Core
+  primary: '#ff0',
+  secondary: '#888',
+  success: '#0f0',
+  error: '#f00',
+  warning: '#fa0',
+  info: '#0af',
+  // Neutral
+  foreground: '#fff',
+  background: 'transparent',
+  muted: '#777',
+  border: '#333',
+  surface: '#000',
+  surfaceHover: '#222',
+  // Context
+  aiLine: '#0a0',
+  userLine: '#08f',
+  agentToggleHeaderBg: '#f60',
+  agentToggleExpandedBg: '#14e',
+  agentFocusedBg: '#334155',
+  agentContentBg: '#000000',
+  // Input
+  inputBg: '#000',
+  inputFg: '#fff',
+  inputFocusedBg: '#000',
+  inputFocusedFg: '#fff',
+  // Modes
+  modeFastBg: '#f60',
+  modeFastText: '#f60',
+  modeMaxBg: '#d22',
+  modeMaxText: '#d22',
+  modePlanBg: '#14e',
+  modePlanText: '#14e',
+  // Markdown
+  markdown: {
+    codeBackground: '#111',
+    codeHeaderFg: '#555',
+    inlineCodeFg: '#fff',
+    codeTextFg: '#fff',
+    headingFg: {
+      1: '#ff0',
+      2: '#ff0',
+      3: '#ff0',
+      4: '#ff0',
+      5: '#ff0',
+      6: '#ff0',
+    },
+    listBulletFg: '#aaa',
+    blockquoteBorderFg: '#444',
+    blockquoteTextFg: '#eee',
+    dividerFg: '#333',
+    codeMonochrome: true,
+  },
+  messageTextAttributes: 0,
+}
+
+describe('SegmentedControl - processSegments', () => {
+  test('computes width from label using string-width', () => {
+    const segments: Segment[] = [
+      { id: 'FAST', label: 'FAST' },
+      { id: 'MAX', label: 'MAX' },
+      { id: 'PLAN', label: 'PLAN' },
+    ]
+
+    const processed = processSegments(segments, null, false, theme)
+    const widths = processed.map((s) => s.width)
+    expect(widths).toEqual([
+      stringWidth(' FAST '),
+      stringWidth(' MAX '),
+      stringWidth(' PLAN '),
+    ])
+  })
+
+  test('applies defaultHighlighted when nothing hovered', () => {
+    const segments: Segment[] = [
+      { id: 'FAST', label: 'FAST' },
+      { id: 'MAX', label: 'MAX' },
+      {
+        id: 'active-FAST',
+        label: '> FAST',
+        isSelected: true,
+        defaultHighlighted: true,
+      },
+    ]
+
+    const processed = processSegments(segments, null, false, theme)
+    const map: Record<string, ProcessedSegment> = Object.fromEntries(
+      processed.map((p) => [p.id, p]),
+    )
+
+    expect(map['active-FAST'].leftBorderColor).toBe(theme.foreground)
+    expect(map['FAST'].leftBorderColor).toBe(theme.border)
+  })
+
+  test('hovering a segment highlights it', () => {
+    const segments: Segment[] = [
+      { id: 'FAST', label: 'FAST' },
+      { id: 'MAX', label: 'MAX' },
+      { id: 'PLAN', label: 'PLAN' },
+    ]
+    const processed = processSegments(segments, 'MAX', true, theme)
+    const map: Record<string, ProcessedSegment> = Object.fromEntries(
+      processed.map((p) => [p.id, p]),
+    )
+
+    expect(map.MAX.isHovered).toBe(true)
+    expect(map.MAX.leftBorderColor).toBe(theme.foreground)
+    expect(map.FAST.leftBorderColor).toBe(theme.border)
+  })
+
+  test('disabled segments use muted text and border colors', () => {
+    const segments: Segment[] = [
+      { id: 'FAST', label: 'FAST', disabled: true },
+      { id: 'MAX', label: 'MAX' },
+    ]
+    const [fast, max] = processSegments(segments, null, false, theme)
+    expect(fast.textColor).toBe(theme.muted)
+    expect(fast.leftBorderColor).toBe(theme.border)
+    expect(max.textColor).toBe(theme.foreground)
+  })
+})
+
+describe('SegmentedControl - string width with double-width glyphs', () => {
+  test('emoji and CJK characters increase width correctly', () => {
+    const segments: Segment[] = [
+      { id: 'E', label: '🚀MAX' },
+      { id: 'CJK', label: '计划' },
+    ]
+
+    const processed = processSegments(segments, null, false, theme)
+
+    expect(processed[0].width).toBe(stringWidth(' 🚀MAX '))
+    expect(processed[1].width).toBe(stringWidth(' 计划 '))
+  })
+})