@sushanglewis/lincoln 1.5.0 → 1.5.1

package/framework/tools/lincoln/tests/components/RecordingApp.test.tsx

@@ -0,0 +1,248 @@
+import { render } from 'ink-testing-library'
+import React from 'react'
+import { afterEach, beforeEach, describe, expect, test, vi } from 'vitest'
+import { RecordingApp } from '../../src/components/RecordingApp'
+import type { RecorderController, RecorderState } from '../../src/recording/useRecorder'
+
+const idleState: RecorderState = {
+  status: 'idle',
+  duration: 0,
+  amplitude: 0,
+  errorMessage: null,
+}
+
+const recordingState: RecorderState = {
+  status: 'recording',
+  duration: 83,
+  amplitude: 0.65,
+  errorMessage: null,
+}
+
+let currentController: RecorderController
+const exitMock = vi.fn()
+
+vi.mock('ink', async () => {
+  const actual = await vi.importActual<typeof import('ink')>('ink')
+  return {
+    ...actual,
+    useApp: () => ({ exit: exitMock }),
+  }
+})
+
+vi.mock('../../src/recording/useRecorder', () => ({
+  useRecorder: vi.fn(() => currentController),
+}))
+
+async function tick() {
+  return new Promise(resolve => setTimeout(resolve, 0))
+}
+
+describe('RecordingApp', () => {
+  beforeEach(() => {
+    currentController = {
+      state: { ...idleState },
+      start: vi.fn(() => {
+        currentController.state = { ...recordingState }
+      }),
+      stop: vi.fn(() => {
+        currentController.state = { status: 'stopped', duration: 83, amplitude: 0, errorMessage: null }
+        return Promise.resolve()
+      }),
+      cancel: vi.fn(() => {
+        currentController.state = { status: 'cancelled', duration: 0, amplitude: 0, errorMessage: null }
+        return Promise.resolve()
+      }),
+    }
+    exitMock.mockClear()
+  })
+
+  afterEach(() => {
+    vi.clearAllMocks()
+  })
+
+  test('renders single HUD initially', () => {
+    const { lastFrame } = render(
+      <RecordingApp
+        workspaceRoot="/workspace"
+        sessionId="2026-06-28-test"
+        topic="测试访谈"
+        designId="test-design"
+        branch="main"
+        audioMeterStyle="bar"
+      />,
+    )
+
+    expect(lastFrame()).toContain('Lincoln Recorder')
+    expect(lastFrame()).toContain('Session: 2026-06-28-test')
+    expect(lastFrame()).toContain('Topic: 测试访谈')
+    expect(lastFrame()).toContain('[r] record  [d] devices  [m] model  [q] quit')
+  })
+
+  test('starts recording when r is pressed', async () => {
+    const { stdin } = render(
+      <RecordingApp
+        workspaceRoot="/workspace"
+        sessionId="2026-06-28-test"
+        topic=""
+        designId=""
+        branch=""
+        audioMeterStyle="bar"
+      />,
+    )
+
+    await tick()
+    stdin.write('r')
+    await tick()
+
+    expect(currentController.start).toHaveBeenCalled()
+  })
+
+  test('exits when q is pressed from idle', async () => {
+    const { stdin } = render(
+      <RecordingApp
+        workspaceRoot="/workspace"
+        sessionId="2026-06-28-test"
+        topic=""
+        designId=""
+        branch=""
+        audioMeterStyle="bar"
+      />,
+    )
+
+    await tick()
+    stdin.write('q')
+    await tick()
+
+    expect(exitMock).toHaveBeenCalled()
+    expect(currentController.start).not.toHaveBeenCalled()
+  })
+
+  test('calls stop when s is pressed during recording', async () => {
+    const { stdin, rerender } = render(
+      <RecordingApp
+        workspaceRoot="/workspace"
+        sessionId="2026-06-28-test"
+        topic=""
+        designId=""
+        branch=""
+        audioMeterStyle="bar"
+      />,
+    )
+
+    await tick()
+    stdin.write('r')
+    await tick()
+    expect(currentController.start).toHaveBeenCalled()
+
+    rerender(
+      <RecordingApp
+        workspaceRoot="/workspace"
+        sessionId="2026-06-28-test"
+        topic=""
+        designId=""
+        branch=""
+        audioMeterStyle="bar"
+      />,
+    )
+    await tick()
+
+    stdin.write('s')
+    await tick()
+
+    expect(currentController.stop).toHaveBeenCalled()
+  })
+
+  test('calls cancel and exits when c is pressed during recording', async () => {
+    const { stdin, rerender } = render(
+      <RecordingApp
+        workspaceRoot="/workspace"
+        sessionId="2026-06-28-test"
+        topic=""
+        designId=""
+        branch=""
+        audioMeterStyle="bar"
+      />,
+    )
+
+    await tick()
+    stdin.write('r')
+    await tick()
+
+    rerender(
+      <RecordingApp
+        workspaceRoot="/workspace"
+        sessionId="2026-06-28-test"
+        topic=""
+        designId=""
+        branch=""
+        audioMeterStyle="bar"
+      />,
+    )
+    await tick()
+
+    stdin.write('c')
+    await tick()
+
+    expect(currentController.cancel).toHaveBeenCalled()
+  })
+
+  test('shows stopped summary when stopped', async () => {
+    currentController.state = { status: 'stopped', duration: 120, amplitude: 0, errorMessage: null }
+
+    const { lastFrame } = render(
+      <RecordingApp
+        workspaceRoot="/workspace"
+        sessionId="2026-06-28-test"
+        topic=""
+        designId=""
+        branch=""
+        audioMeterStyle="bar"
+      />,
+    )
+
+    await tick()
+    expect(lastFrame()).toContain('Stopped')
+    expect(lastFrame()).toContain('claude process-interview 2026-06-28-test')
+    expect(lastFrame()).toContain('[any key] exit')
+  })
+
+  test('exits when any key is pressed on stopped screen', async () => {
+    currentController.state = { status: 'stopped', duration: 120, amplitude: 0, errorMessage: null }
+
+    const { stdin } = render(
+      <RecordingApp
+        workspaceRoot="/workspace"
+        sessionId="2026-06-28-test"
+        topic=""
+        designId=""
+        branch=""
+        audioMeterStyle="bar"
+      />,
+    )
+
+    await tick()
+    stdin.write('y')
+    await tick()
+
+    expect(exitMock).toHaveBeenCalled()
+  })
+
+  test('logs error when recorder fails', async () => {
+    currentController.state = { status: 'error', duration: 0, amplitude: 0, errorMessage: 'microphone not found' }
+
+    const { lastFrame } = render(
+      <RecordingApp
+        workspaceRoot="/workspace"
+        sessionId="2026-06-28-test"
+        topic=""
+        designId=""
+        branch=""
+        audioMeterStyle="bar"
+      />,
+    )
+
+    await tick()
+    expect(lastFrame()).toContain('microphone not found')
+    expect(lastFrame()).toContain('[q] exit')
+  })
+})

package/framework/tools/lincoln/tests/components/RecordingScreen.test.tsx

@@ -0,0 +1,37 @@
+import { render } from 'ink-testing-library'
+import React from 'react'
+import { describe, expect, test } from 'vitest'
+import { RecordingScreen } from '../../src/components/RecordingScreen'
+
+describe('RecordingScreen', () => {
+  test('renders session info and recording status', () => {
+    const { lastFrame } = render(
+      <RecordingScreen
+        sessionId="2026-06-28-test"
+        topic="测试访谈"
+        designId="test-design"
+        duration={83}
+        amplitude={0.65}
+      />,
+    )
+
+    expect(lastFrame()).toContain('2026-06-28-test')
+    expect(lastFrame()).toContain('测试访谈')
+    expect(lastFrame()).toContain('Recording')
+    expect(lastFrame()).toContain('01:23')
+  })
+
+  test('renders audio meter when enabled', () => {
+    const { lastFrame } = render(
+      <RecordingScreen
+        sessionId="2026-06-28-test"
+        topic=""
+        designId=""
+        duration={0}
+        amplitude={0.8}
+      />,
+    )
+
+    expect(lastFrame()).toContain('█')
+  })
+})

package/framework/tools/lincoln/tests/components/SelectMenu.test.tsx

@@ -0,0 +1,59 @@
+import { render } from 'ink-testing-library'
+import React from 'react'
+import { describe, expect, test, vi } from 'vitest'
+import { SelectMenu } from '../../src/components/SelectMenu'
+
+async function tick() {
+  return new Promise(resolve => setTimeout(resolve, 0))
+}
+
+const items = [
+  { key: 'a', label: 'Mic A' },
+  { key: 'b', label: 'Mic B' },
+]
+
+describe('SelectMenu', () => {
+  test('renders title and items with the first one selected', () => {
+    const { lastFrame } = render(
+      <SelectMenu title="Devices" items={items} onSelect={() => {}} onClose={() => {}} />,
+    )
+    expect(lastFrame()).toContain('Devices')
+    expect(lastFrame()).toContain('› Mic A')
+    expect(lastFrame()).toContain('  Mic B')
+  })
+
+  test('moves selection with the down arrow', async () => {
+    const { lastFrame, stdin } = render(
+      <SelectMenu title="Devices" items={items} onSelect={() => {}} onClose={() => {}} />,
+    )
+    await tick()
+    stdin.write('')
+    await tick()
+    expect(lastFrame()).toContain('  Mic A')
+    expect(lastFrame()).toContain('› Mic B')
+  })
+
+  test('calls onSelect with the highlighted key on enter', async () => {
+    const onSelect = vi.fn()
+    const { stdin } = render(
+      <SelectMenu title="Devices" items={items} onSelect={onSelect} onClose={() => {}} />,
+    )
+    await tick()
+    stdin.write('')
+    await tick()
+    stdin.write('\r')
+    await tick()
+    expect(onSelect).toHaveBeenCalledWith('b')
+  })
+
+  test('calls onClose on escape', async () => {
+    const onClose = vi.fn()
+    const { stdin } = render(
+      <SelectMenu title="Devices" items={items} onSelect={() => {}} onClose={onClose} />,
+    )
+    await tick()
+    stdin.write('')
+    await tick()
+    expect(onClose).toHaveBeenCalledTimes(1)
+  })
+})

package/framework/tools/lincoln/tests/components/StopConfirmation.test.tsx

@@ -0,0 +1,38 @@
+import { render } from 'ink-testing-library'
+import React from 'react'
+import { describe, expect, test, vi } from 'vitest'
+import { StopConfirmation } from '../../src/components/StopConfirmation'
+
+async function tick() {
+  return new Promise(resolve => setTimeout(resolve, 0))
+}
+
+describe('StopConfirmation', () => {
+  test('renders command and workspace', () => {
+    const { lastFrame } = render(
+      <StopConfirmation
+        sessionId="2026-06-28-test"
+        workspaceRoot="/workspace"
+        onConfirm={vi.fn()}
+      />,
+    )
+
+    expect(lastFrame()).toContain('Stopped')
+    expect(lastFrame()).toContain('Session 2026-06-28-test saved.')
+    expect(lastFrame()).toContain('Workspace: /workspace')
+    expect(lastFrame()).toContain('claude process-interview 2026-06-28-test')
+  })
+
+  test('calls onConfirm when any key is pressed', async () => {
+    const onConfirm = vi.fn()
+    const { stdin } = render(
+      <StopConfirmation sessionId="2026-06-28-test" onConfirm={onConfirm} />,
+    )
+
+    await tick()
+    stdin.write('y')
+    await tick()
+
+    expect(onConfirm).toHaveBeenCalledTimes(1)
+  })
+})

package/framework/tools/lincoln/tests/config/args.test.ts

@@ -0,0 +1,49 @@
+import { describe, expect, test } from 'vitest'
+import { parseArgs } from '../../src/config/args'
+
+describe('parseArgs', () => {
+  test('returns defaults when no args are provided', () => {
+    const result = parseArgs([])
+
+    expect(result.topic).toBeUndefined()
+    expect(result.designId).toBeUndefined()
+    expect(result.branch).toBeUndefined()
+    expect(result.sessionId).toBeUndefined()
+    expect(result.noTui).toBe(false)
+    expect(result.help).toBe(false)
+  })
+
+  test('parses --topic, --design-id, and --branch', () => {
+    const result = parseArgs([
+      '--topic',
+      '结算流程 redesign 需求访谈',
+      '--design-id',
+      'checkout-redesign',
+      '--branch',
+      'pm-workflow-integration-plugin',
+    ])
+
+    expect(result.topic).toBe('结算流程 redesign 需求访谈')
+    expect(result.designId).toBe('checkout-redesign')
+    expect(result.branch).toBe('pm-workflow-integration-plugin')
+  })
+
+  test('parses --no-tui', () => {
+    const result = parseArgs(['--no-tui'])
+
+    expect(result.noTui).toBe(true)
+  })
+
+  test('parses --help', () => {
+    const result = parseArgs(['--help'])
+
+    expect(result.help).toBe(true)
+  })
+
+  test('ignores unknown options and positional arguments', () => {
+    const result = parseArgs(['--unknown', 'value', 'positional'])
+
+    expect(result.topic).toBeUndefined()
+    expect(result.noTui).toBe(false)
+  })
+})

package/framework/tools/lincoln/tests/config/loadConfig.test.ts

@@ -0,0 +1,59 @@
+import { mkdtempSync, writeFileSync } from 'node:fs'
+import { tmpdir } from 'node:os'
+import { join } from 'node:path'
+import { describe, expect, test } from 'vitest'
+import { loadConfig, loadConfigOptional } from '../../src/config/loadConfig'
+
+describe('loadConfig', () => {
+  test('loads a valid YAML config', () => {
+    const dir = mkdtempSync(join(tmpdir(), 'lincoln-config-'))
+    const path = join(dir, '.lincolnrc')
+    writeFileSync(path, 'default_design_id: checkout-redesign\nshow_audio_meter: true\n', 'utf-8')
+
+    const result = loadConfig(path)
+
+    expect(result.defaultDesignId).toBe('checkout-redesign')
+    expect(result.showAudioMeter).toBe(true)
+  })
+
+  test('loads a valid JSON config', () => {
+    const dir = mkdtempSync(join(tmpdir(), 'lincoln-config-'))
+    const path = join(dir, '.lincolnrc.json')
+    writeFileSync(path, JSON.stringify({ auto_process: false, audio_meter_style: 'dot' }), 'utf-8')
+
+    const result = loadConfig(path)
+
+    expect(result.autoProcess).toBe(false)
+    expect(result.audioMeterStyle).toBe('dot')
+  })
+
+  test('throws when config file is missing', () => {
+    expect(() => loadConfig('/nonexistent/.lincolnrc')).toThrow('Config file not found')
+  })
+
+  test('throws when config file has invalid YAML', () => {
+    const dir = mkdtempSync(join(tmpdir(), 'lincoln-config-'))
+    const path = join(dir, '.lincolnrc')
+    writeFileSync(path, '{ invalid yaml', 'utf-8')
+
+    expect(() => loadConfig(path)).toThrow('Failed to parse config')
+  })
+})
+
+describe('loadConfigOptional', () => {
+  test('returns empty config when file is missing', () => {
+    const result = loadConfigOptional('/nonexistent/.lincolnrc')
+
+    expect(result).toEqual({})
+  })
+
+  test('returns parsed config when file exists', () => {
+    const dir = mkdtempSync(join(tmpdir(), 'lincoln-config-'))
+    const path = join(dir, '.lincolnrc')
+    writeFileSync(path, 'default_topic: "结算流程 redesign 需求访谈"\n', 'utf-8')
+
+    const result = loadConfigOptional(path)
+
+    expect(result.defaultTopic).toBe('结算流程 redesign 需求访谈')
+  })
+})

package/framework/tools/lincoln/tests/config/resolveConfig.test.ts

@@ -0,0 +1,72 @@
+import { mkdirSync, mkdtempSync, writeFileSync } from 'node:fs'
+import { tmpdir } from 'node:os'
+import { join } from 'node:path'
+import { describe, expect, test } from 'vitest'
+import { resolveConfig } from '../../src/config/resolveConfig'
+
+describe('resolveConfig', () => {
+  test('uses defaults when no args and no config files exist', () => {
+    const dir = mkdtempSync(join(tmpdir(), 'lincoln-resolve-'))
+
+    const result = resolveConfig({}, { cwd: dir, home: dir, now: new Date('2026-06-28T00:00:00Z') })
+
+    expect(result.sessionId).toMatch(/^2026-06-28-/)
+    expect(result.noTui).toBe(false)
+  })
+
+  test('CLI args override global config', () => {
+    const home = mkdtempSync(join(tmpdir(), 'lincoln-home-'))
+    writeFileSync(join(home, '.lincolnrc'), 'default_design_id: global-design\n', 'utf-8')
+
+    const result = resolveConfig(
+      { designId: 'cli-design' },
+      { cwd: home, home, now: new Date('2026-06-28T00:00:00Z') },
+    )
+
+    expect(result.designId).toBe('cli-design')
+  })
+
+  test('local config overrides global config', () => {
+    const home = mkdtempSync(join(tmpdir(), 'lincoln-home-'))
+    const cwd = mkdtempSync(join(tmpdir(), 'lincoln-cwd-'))
+    writeFileSync(join(home, '.lincolnrc'), 'default_design_id: global-design\n', 'utf-8')
+    writeFileSync(join(cwd, '.lincolnrc'), 'default_design_id: local-design\n', 'utf-8')
+
+    const result = resolveConfig({}, { cwd, home, now: new Date('2026-06-28T00:00:00Z') })
+
+    expect(result.designId).toBe('local-design')
+  })
+
+  test('uses global config when no local config or CLI args', () => {
+    const home = mkdtempSync(join(tmpdir(), 'lincoln-home-'))
+    const cwd = mkdtempSync(join(tmpdir(), 'lincoln-cwd-'))
+    writeFileSync(join(home, '.lincolnrc'), 'default_topic: "全局主题"\n', 'utf-8')
+
+    const result = resolveConfig({}, { cwd, home, now: new Date('2026-06-28T00:00:00Z') })
+
+    expect(result.topic).toBe('全局主题')
+  })
+
+  test('preserves CLI noTui flag', () => {
+    const dir = mkdtempSync(join(tmpdir(), 'lincoln-resolve-'))
+
+    const result = resolveConfig(
+      { noTui: true },
+      { cwd: dir, home: dir, now: new Date('2026-06-28T00:00:00Z') },
+    )
+
+    expect(result.noTui).toBe(true)
+  })
+
+  test('appends counter when recording file already exists', () => {
+    const dir = mkdtempSync(join(tmpdir(), 'lincoln-resolve-'))
+    const recordingsDir = join(dir, 'recordings')
+    mkdirSync(recordingsDir)
+    writeFileSync(join(recordingsDir, '2026-06-28-recording.m4a'), '', 'utf-8')
+    writeFileSync(join(recordingsDir, '2026-06-28-recording-001.m4a'), '', 'utf-8')
+
+    const result = resolveConfig({}, { cwd: dir, home: dir, now: new Date('2026-06-28T00:00:00Z') })
+
+    expect(result.sessionId).toBe('2026-06-28-recording-002')
+  })
+})

package/framework/tools/lincoln/tests/devices/parseDevices.test.ts

@@ -0,0 +1,21 @@
+import { describe, expect, test } from 'vitest'
+import { parseDevicesOutput } from '../../src/devices/parseDevices'
+
+describe('parseDevicesOutput', () => {
+  test('parses default device and device list', () => {
+    const output = 'Default input: MacBook Pro Microphone\n  MacBook Pro Microphone\n  External Mic\n'
+    const result = parseDevicesOutput(output)
+    expect(result.defaultDevice).toBe('MacBook Pro Microphone')
+    expect(result.devices).toEqual(['MacBook Pro Microphone', 'External Mic'])
+  })
+
+  test('returns null default when the line is missing', () => {
+    const result = parseDevicesOutput('  Mic A\n')
+    expect(result.defaultDevice).toBeNull()
+    expect(result.devices).toEqual(['Mic A'])
+  })
+
+  test('returns empty result for empty output', () => {
+    expect(parseDevicesOutput('')).toEqual({ defaultDevice: null, devices: [] })
+  })
+})

package/framework/tools/lincoln/tests/hooks/useKeyHandler.enabled.test.tsx

@@ -0,0 +1,44 @@
+import { Text } from 'ink'
+import { render } from 'ink-testing-library'
+import React from 'react'
+import { describe, expect, test, vi } from 'vitest'
+import { useKeyHandler } from '../../src/hooks/useKeyHandler'
+
+const onRecordMock = vi.fn()
+const onQuitMock = vi.fn()
+
+function TestComponent({ enabled }: { enabled: boolean }) {
+  useKeyHandler({ enabled, onRecord: onRecordMock, onQuit: onQuitMock })
+  return <Text>handlers active</Text>
+}
+
+async function tick() {
+  return new Promise(resolve => setTimeout(resolve, 0))
+}
+
+describe('useKeyHandler enabled flag', () => {
+  test('ignores all keys when disabled', async () => {
+    onRecordMock.mockClear()
+    onQuitMock.mockClear()
+    const { stdin } = render(<TestComponent enabled={false} />)
+
+    await tick()
+    stdin.write('r')
+    stdin.write('q')
+    await tick()
+
+    expect(onRecordMock).not.toHaveBeenCalled()
+    expect(onQuitMock).not.toHaveBeenCalled()
+  })
+
+  test('handles keys when enabled', async () => {
+    onRecordMock.mockClear()
+    const { stdin } = render(<TestComponent enabled />)
+
+    await tick()
+    stdin.write('r')
+    await tick()
+
+    expect(onRecordMock).toHaveBeenCalledTimes(1)
+  })
+})