nastech-tui 0.0.1

package/src/__tests__/asCommandDispatch.test.ts

@@ -0,0 +1,27 @@
+import { describe, expect, it } from 'vitest'
+
+import { asCommandDispatch } from '../lib/rpc.js'
+
+describe('asCommandDispatch', () => {
+  it('parses exec, alias, skill, and send', () => {
+    expect(asCommandDispatch({ type: 'exec', output: 'hi' })).toEqual({ type: 'exec', output: 'hi' })
+    expect(asCommandDispatch({ type: 'alias', target: 'help' })).toEqual({ type: 'alias', target: 'help' })
+    expect(asCommandDispatch({ type: 'skill', name: 'x', message: 'do' })).toEqual({
+      type: 'skill',
+      name: 'x',
+      message: 'do'
+    })
+    expect(asCommandDispatch({ type: 'send', message: 'hello world' })).toEqual({
+      type: 'send',
+      message: 'hello world'
+    })
+  })
+
+  it('rejects malformed payloads', () => {
+    expect(asCommandDispatch(null)).toBeNull()
+    expect(asCommandDispatch({ type: 'alias' })).toBeNull()
+    expect(asCommandDispatch({ type: 'skill', name: 1 })).toBeNull()
+    expect(asCommandDispatch({ type: 'send' })).toBeNull()
+    expect(asCommandDispatch({ type: 'send', message: 42 })).toBeNull()
+  })
+})

package/src/__tests__/blockLayout.test.ts

@@ -0,0 +1,122 @@
+import { describe, expect, it } from 'vitest'
+
+import { blockRenders, hasLeadGap, messageGroup, prevRenderedMsg } from '../domain/blockLayout.js'
+import type { Msg } from '../types.js'
+
+const m = (over: Partial<Msg>): Msg => ({ role: 'assistant', text: '', ...over })
+
+describe('messageGroup', () => {
+  it('classifies each block kind into its visual band', () => {
+    expect(messageGroup(m({ role: 'assistant' }))).toBe('model')
+    expect(messageGroup(m({ role: 'assistant', kind: 'diff' }))).toBe('diff')
+    expect(messageGroup(m({ role: 'system', kind: 'trail' }))).toBe('trail')
+    expect(messageGroup(m({ role: 'system' }))).toBe('note')
+    expect(messageGroup(m({ role: 'user' }))).toBe('user')
+    expect(messageGroup(m({ role: 'user', kind: 'slash' }))).toBe('slash')
+    expect(messageGroup(m({ role: 'system', kind: 'intro' }))).toBe('intro')
+    expect(messageGroup(m({ role: 'system', kind: 'panel' }))).toBe('intro')
+  })
+})
+
+describe('hasLeadGap', () => {
+  const trail = m({ role: 'system', kind: 'trail' })
+  const model = m({ role: 'assistant' })
+  const note = m({ role: 'system' })
+  const user = m({ role: 'user' })
+  const diff = m({ role: 'assistant', kind: 'diff' })
+  const slash = m({ role: 'user', kind: 'slash' })
+
+  it('opens a gap only at a boundary between working-area groups', () => {
+    expect(hasLeadGap(trail, model)).toBe(true)
+    expect(hasLeadGap(model, trail)).toBe(true)
+    expect(hasLeadGap(model, note)).toBe(true)
+    expect(hasLeadGap(note, model)).toBe(true)
+  })
+
+  it('keeps same-group neighbours flush (the grouping)', () => {
+    expect(hasLeadGap(trail, trail)).toBe(false)
+    expect(hasLeadGap(model, model)).toBe(false)
+    expect(hasLeadGap(note, note)).toBe(false)
+  })
+
+  it('never gaps the first block (no predecessor)', () => {
+    expect(hasLeadGap(undefined, model)).toBe(false)
+    expect(hasLeadGap(undefined, trail)).toBe(false)
+  })
+
+  it('suppresses the gap after blocks that already paint a trailing line', () => {
+    // user and diff carry their own marginBottom — the following block must
+    // not add a second blank line on top of it.
+    expect(hasLeadGap(user, trail)).toBe(false)
+    expect(hasLeadGap(user, model)).toBe(false)
+    expect(hasLeadGap(diff, model)).toBe(false)
+  })
+
+  it('still gaps after a slash echo (it has no trailing margin)', () => {
+    expect(hasLeadGap(slash, model)).toBe(true)
+    expect(hasLeadGap(slash, trail)).toBe(true)
+  })
+
+  it('lets user / slash / diff own their spacing (never managed here)', () => {
+    expect(hasLeadGap(model, user)).toBe(false)
+    expect(hasLeadGap(model, slash)).toBe(false)
+    expect(hasLeadGap(model, diff)).toBe(false)
+  })
+})
+
+describe('blockRenders', () => {
+  const trail: Msg = { role: 'system', kind: 'trail', text: '', tools: ['Edit foo.ts'] }
+  const model: Msg = { role: 'assistant', text: 'hi' }
+  const todos: Msg = { role: 'system', kind: 'trail', text: '', todos: [{ content: 'a', id: '1', status: 'pending' }] }
+
+  it('always renders non-trail blocks', () => {
+    expect(blockRenders(model, { detailsMode: 'hidden', commandOverride: true })).toBe(true)
+  })
+
+  it('renders a content-bearing trail unless every section is hidden', () => {
+    expect(blockRenders(trail, { detailsMode: 'collapsed' })).toBe(true)
+    expect(blockRenders(trail, { detailsMode: 'expanded' })).toBe(true)
+    // /details hidden routes through commandOverride, which hides every section.
+    expect(blockRenders(trail, { detailsMode: 'hidden', commandOverride: true })).toBe(false)
+  })
+
+  it('does not render a content-less trail (e.g. finalDetails with only a token tally)', () => {
+    const tally: Msg = { role: 'system', kind: 'trail', text: '', toolTokens: 40 }
+
+    expect(blockRenders(tally, { detailsMode: 'expanded' })).toBe(false)
+  })
+
+  it('keeps todo trails visible even when details are hidden', () => {
+    expect(blockRenders(todos, { detailsMode: 'hidden', commandOverride: true })).toBe(true)
+  })
+})
+
+describe('prevRenderedMsg', () => {
+  const hiddenCtx = { commandOverride: true, detailsMode: 'hidden' as const }
+  const shownCtx = { detailsMode: 'collapsed' as const }
+
+  const rows: Msg[] = [
+    { role: 'user', text: 'q' }, // 0
+    { role: 'system', kind: 'trail', text: '', tools: ['Edit foo.ts'] }, // 1
+    { role: 'assistant', text: 'first' }, // 2
+    { role: 'system', kind: 'trail', text: '', tools: ['Edit bar.ts'] }, // 3
+    { role: 'assistant', text: 'second' } // 4
+  ]
+  const at = (i: number) => rows[i]
+
+  it('returns the literal predecessor when everything renders', () => {
+    expect(prevRenderedMsg(at, 2, shownCtx)).toBe(rows[1])
+    expect(prevRenderedMsg(at, 4, shownCtx)).toBe(rows[3])
+  })
+
+  it('skips hidden trails so grouping sees the nearest visible block', () => {
+    // With trails hidden, the prose at index 2 groups against the user (not the
+    // invisible trail) and the prose at index 4 groups against the prose at 2.
+    expect(prevRenderedMsg(at, 2, hiddenCtx)).toBe(rows[0])
+    expect(prevRenderedMsg(at, 4, hiddenCtx)).toBe(rows[2])
+  })
+
+  it('returns undefined at the top of the transcript', () => {
+    expect(prevRenderedMsg(at, 0, shownCtx)).toBeUndefined()
+  })
+})

package/src/__tests__/clipboard.test.ts

@@ -0,0 +1,369 @@
+import { describe, expect, it, vi } from 'vitest'
+
+import { isUsableClipboardText, readClipboardText, writeClipboardText } from '../lib/clipboard.js'
+
+describe('readClipboardText', () => {
+  it('reads text from pbpaste on macOS', async () => {
+    const run = vi.fn().mockResolvedValue({ stdout: 'hello world\n' })
+
+    await expect(readClipboardText('darwin', run)).resolves.toBe('hello world\n')
+    expect(run).toHaveBeenCalledWith(
+      'pbpaste',
+      [],
+      expect.objectContaining({ encoding: 'utf8', maxBuffer: 4 * 1024 * 1024, windowsHide: true })
+    )
+  })
+
+  it('reads text from PowerShell on Windows', async () => {
+    const run = vi.fn().mockResolvedValue({ stdout: 'from windows\r\n' })
+
+    await expect(readClipboardText('win32', run)).resolves.toBe('from windows\r\n')
+    expect(run).toHaveBeenCalledWith(
+      'powershell',
+      ['-NoProfile', '-NonInteractive', '-Command', 'Get-Clipboard -Raw'],
+      expect.objectContaining({ encoding: 'utf8', maxBuffer: 4 * 1024 * 1024, windowsHide: true })
+    )
+  })
+
+  it('tries powershell.exe first on WSL', async () => {
+    const run = vi.fn().mockResolvedValue({ stdout: 'from wsl\n' })
+
+    await expect(readClipboardText('linux', run, { WSL_INTEROP: '/tmp/socket' } as NodeJS.ProcessEnv)).resolves.toBe(
+      'from wsl\n'
+    )
+    expect(run).toHaveBeenCalledWith(
+      'powershell.exe',
+      ['-NoProfile', '-NonInteractive', '-Command', 'Get-Clipboard -Raw'],
+      expect.objectContaining({ encoding: 'utf8', maxBuffer: 4 * 1024 * 1024, windowsHide: true })
+    )
+  })
+
+  it('uses wl-paste on Wayland Linux', async () => {
+    const run = vi.fn().mockResolvedValue({ stdout: 'from wayland\n' })
+
+    await expect(readClipboardText('linux', run, { WAYLAND_DISPLAY: 'wayland-1' } as NodeJS.ProcessEnv)).resolves.toBe(
+      'from wayland\n'
+    )
+    expect(run).toHaveBeenCalledWith(
+      'wl-paste',
+      ['--type', 'text'],
+      expect.objectContaining({ encoding: 'utf8', maxBuffer: 4 * 1024 * 1024, windowsHide: true })
+    )
+  })
+
+  it('falls back to xclip on Linux when wl-paste fails', async () => {
+    const run = vi
+      .fn()
+      .mockRejectedValueOnce(new Error('wl-paste missing'))
+      .mockResolvedValueOnce({ stdout: 'from xclip\n' })
+
+    await expect(readClipboardText('linux', run, { WAYLAND_DISPLAY: 'wayland-1' } as NodeJS.ProcessEnv)).resolves.toBe(
+      'from xclip\n'
+    )
+    expect(run).toHaveBeenNthCalledWith(
+      1,
+      'wl-paste',
+      ['--type', 'text'],
+      expect.objectContaining({ encoding: 'utf8', maxBuffer: 4 * 1024 * 1024, windowsHide: true })
+    )
+    expect(run).toHaveBeenNthCalledWith(
+      2,
+      'xclip',
+      ['-selection', 'clipboard', '-out'],
+      expect.objectContaining({ encoding: 'utf8', maxBuffer: 4 * 1024 * 1024, windowsHide: true })
+    )
+  })
+
+  it('returns null when every clipboard backend fails', async () => {
+    const run = vi.fn().mockRejectedValue(new Error('clipboard failed'))
+
+    await expect(
+      readClipboardText('linux', run, { WAYLAND_DISPLAY: 'wayland-1' } as NodeJS.ProcessEnv)
+    ).resolves.toBeNull()
+  })
+})
+
+describe('isUsableClipboardText', () => {
+  it('accepts normal text', () => {
+    expect(isUsableClipboardText('hello world\n')).toBe(true)
+  })
+
+  it('rejects empty or whitespace-only content', () => {
+    expect(isUsableClipboardText('')).toBe(false)
+    expect(isUsableClipboardText('  \n\t')).toBe(false)
+  })
+
+  it('rejects binary-looking clipboard payloads', () => {
+    expect(isUsableClipboardText('PNG\u0000\u0001\u0002\u0003IHDR')).toBe(false)
+    expect(isUsableClipboardText('TIFF\ufffd\ufffd\ufffdmetadata')).toBe(false)
+  })
+})
+
+describe('writeClipboardText', () => {
+  it('does nothing off macOS when no tools are available', async () => {
+    const child = {
+      once: vi.fn((event: string, cb: (code?: number) => void) => {
+        if (event === 'close') {
+          cb(1) // non-zero exit = failure
+        }
+
+        return child
+      }),
+      stdin: { end: vi.fn() }
+    }
+
+    const start = vi.fn().mockReturnValue(child)
+
+    // Linux with no WAYLAND_DISPLAY / no WSL_INTEROP — falls through xclip then xsel, both fail
+    await expect(writeClipboardText('hello', 'linux', start, {})).resolves.toBe(false)
+  })
+
+  it('writes text to pbcopy on macOS', async () => {
+    const stdin = { end: vi.fn() }
+
+    const child = {
+      once: vi.fn((event: string, cb: (code?: number) => void) => {
+        if (event === 'close') {
+          cb(0)
+        }
+
+        return child
+      }),
+      stdin
+    }
+
+    const start = vi.fn().mockReturnValue(child)
+
+    await expect(writeClipboardText('hello world', 'darwin', start as any)).resolves.toBe(true)
+    expect(start).toHaveBeenCalledWith(
+      'pbcopy',
+      [],
+      expect.objectContaining({ stdio: ['pipe', 'ignore', 'ignore'], windowsHide: true })
+    )
+    expect(stdin.end).toHaveBeenCalledWith('hello world')
+  })
+
+  it('returns false when pbcopy fails', async () => {
+    const child = {
+      once: vi.fn((event: string, cb: () => void) => {
+        if (event === 'error') {
+          cb()
+        }
+
+        return child
+      }),
+      stdin: { end: vi.fn() }
+    }
+
+    const start = vi.fn().mockReturnValue(child)
+
+    await expect(writeClipboardText('hello world', 'darwin', start as any)).resolves.toBe(false)
+  })
+
+  it('uses wl-copy on Wayland Linux', async () => {
+    const stdin = { end: vi.fn() }
+
+    const child = {
+      once: vi.fn((event: string, cb: (code?: number) => void) => {
+        if (event === 'close') {
+          cb(0)
+        }
+
+        return child
+      }),
+      stdin
+    }
+
+    const start = vi.fn().mockReturnValue(child)
+
+    await expect(
+      writeClipboardText('wayland text', 'linux', start as any, { WAYLAND_DISPLAY: 'wayland-1' })
+    ).resolves.toBe(true)
+    expect(start).toHaveBeenCalledWith(
+      'wl-copy',
+      ['--type', 'text/plain'],
+      expect.objectContaining({ stdio: ['pipe', 'ignore', 'ignore'], windowsHide: true })
+    )
+    expect(stdin.end).toHaveBeenCalledWith('wayland text')
+  })
+
+  it('falls back to xclip when wl-copy fails on Wayland', async () => {
+    let callCount = 0
+    const stdin = { end: vi.fn() }
+
+    const child = {
+      once: vi.fn((event: string, cb: (code?: number) => void) => {
+        if (event === 'close') {
+          callCount++
+          // wl-copy fails, xclip succeeds
+          cb(callCount === 1 ? 1 : 0)
+        }
+
+        return child
+      }),
+      stdin
+    }
+
+    const start = vi.fn().mockReturnValue(child)
+
+    await expect(
+      writeClipboardText('x11 text', 'linux', start as any, { WAYLAND_DISPLAY: 'wayland-1' })
+    ).resolves.toBe(true)
+    expect(start).toHaveBeenNthCalledWith(
+      1,
+      'wl-copy',
+      ['--type', 'text/plain'],
+      expect.anything()
+    )
+    expect(start).toHaveBeenNthCalledWith(
+      2,
+      'xclip',
+      ['-selection', 'clipboard', '-in'],
+      expect.anything()
+    )
+  })
+
+  it('falls back to xsel when both wl-copy and xclip fail', async () => {
+    let callCount = 0
+    const stdin = { end: vi.fn() }
+
+    const child = {
+      once: vi.fn((event: string, cb: (code?: number) => void) => {
+        if (event === 'close') {
+          callCount++
+          cb(callCount < 3 ? 1 : 0) // first two fail, third (xsel) succeeds
+        }
+
+        return child
+      }),
+      stdin
+    }
+
+    const start = vi.fn().mockReturnValue(child)
+
+    await expect(
+      writeClipboardText('xsel text', 'linux', start as any, { WAYLAND_DISPLAY: 'wayland-1' })
+    ).resolves.toBe(true)
+    expect(start).toHaveBeenNthCalledWith(3, 'xsel', ['--clipboard', '--input'], expect.anything())
+  })
+
+  it('uses PowerShell on WSL2 when WSL_DISTRO_NAME is set', async () => {
+    const stdin = { end: vi.fn() }
+
+    const child = {
+      once: vi.fn((event: string, cb: (code?: number) => void) => {
+        if (event === 'close') {
+          cb(0)
+        }
+
+        return child
+      }),
+      stdin
+    }
+
+    const start = vi.fn().mockReturnValue(child)
+
+    await expect(writeClipboardText('wsl text', 'linux', start as any, { WSL_DISTRO_NAME: 'Ubuntu' })).resolves.toBe(true)
+    expect(start).toHaveBeenCalledWith(
+      'powershell.exe',
+      expect.arrayContaining(['-NoProfile', '-NonInteractive']),
+      expect.anything()
+    )
+    // PowerShell uses base64-encoded UTF-8 via command argument, not stdin
+    expect(stdin.end).not.toHaveBeenCalled()
+    const calledArgs = start.mock.calls[0][1] as string[]
+    const commandIdx = calledArgs.indexOf('-Command')
+    expect(commandIdx).toBeGreaterThan(-1)
+    const script = calledArgs[commandIdx + 1]
+    expect(script).toContain('FromBase64String')
+    expect(script).toContain(Buffer.from('wsl text', 'utf8').toString('base64'))
+  })
+
+  it('prefers the Windows clipboard path over wl-copy inside WSLg', async () => {
+    const stdin = { end: vi.fn() }
+
+    const child = {
+      once: vi.fn((event: string, cb: (code?: number) => void) => {
+        if (event === 'close') {
+          cb(0)
+        }
+
+        return child
+      }),
+      stdin
+    }
+
+    const start = vi.fn().mockReturnValue(child)
+
+    await expect(
+      writeClipboardText('wslg text', 'linux', start as any, {
+        WAYLAND_DISPLAY: 'wayland-0',
+        WSL_DISTRO_NAME: 'Ubuntu'
+      })
+    ).resolves.toBe(true)
+    expect(start).toHaveBeenNthCalledWith(
+      1,
+      'powershell.exe',
+      expect.arrayContaining(['-NoProfile', '-NonInteractive']),
+      expect.anything()
+    )
+    // PowerShell uses base64-encoded UTF-8 via command argument, not stdin
+    expect(stdin.end).not.toHaveBeenCalled()
+    const calledArgs = start.mock.calls[0][1] as string[]
+    const commandIdx = calledArgs.indexOf('-Command')
+    const script = calledArgs[commandIdx + 1]
+    expect(script).toContain('FromBase64String')
+    expect(script).toContain(Buffer.from('wslg text', 'utf8').toString('base64'))
+  })
+
+  it('uses PowerShell on Windows', async () => {
+    const stdin = { end: vi.fn() }
+
+    const child = {
+      once: vi.fn((event: string, cb: (code?: number) => void) => {
+        if (event === 'close') {
+          cb(0)
+        }
+
+        return child
+      }),
+      stdin
+    }
+
+    const start = vi.fn().mockReturnValue(child)
+
+    await expect(writeClipboardText('windows text', 'win32', start as any)).resolves.toBe(true)
+    expect(start).toHaveBeenCalledWith(
+      'powershell',
+      expect.arrayContaining(['-NoProfile', '-NonInteractive']),
+      expect.anything()
+    )
+    // PowerShell uses base64-encoded UTF-8 via command argument, not stdin
+    expect(stdin.end).not.toHaveBeenCalled()
+  })
+
+  it('preserves CJK text via base64 encoding in PowerShell on WSL', async () => {
+    const stdin = { end: vi.fn() }
+
+    const child = {
+      once: vi.fn((event: string, cb: (code?: number) => void) => {
+        if (event === 'close') {
+          cb(0)
+        }
+
+        return child
+      }),
+      stdin
+    }
+
+    const start = vi.fn().mockReturnValue(child)
+    const cjkText = '你好世界，测试中文 🎉'
+
+    await expect(writeClipboardText(cjkText, 'linux', start as any, { WSL_INTEROP: '/tmp/socket' })).resolves.toBe(true)
+    const calledArgs = start.mock.calls[0][1] as string[]
+    const commandIdx = calledArgs.indexOf('-Command')
+    const script = calledArgs[commandIdx + 1]
+    expect(script).toContain(Buffer.from(cjkText, 'utf8').toString('base64'))
+    expect(script).toContain('UTF8.GetString')
+  })
+})

package/src/__tests__/constants.test.ts

@@ -0,0 +1,53 @@
+import { describe, expect, it } from 'vitest'
+
+import { FACES } from '../content/faces.js'
+import { HOTKEYS } from '../content/hotkeys.js'
+import { PLACEHOLDERS } from '../content/placeholders.js'
+import { TOOL_VERBS, VERBS } from '../content/verbs.js'
+import { ROLE } from '../domain/roles.js'
+import { ZERO } from '../domain/usage.js'
+import { INTERPOLATION_RE } from '../protocol/interpolation.js'
+import { DEFAULT_THEME } from '../theme.js'
+
+describe('constants', () => {
+  it('ZERO', () => expect(ZERO).toEqual({ calls: 0, input: 0, output: 0, total: 0 }))
+
+  it('string arrays are populated', () => {
+    for (const arr of [FACES, PLACEHOLDERS, VERBS]) {
+      expect(arr.length).toBeGreaterThan(0)
+      arr.forEach(s => expect(typeof s).toBe('string'))
+    }
+  })
+
+  it('HOTKEYS are [key, desc] pairs', () => {
+    HOTKEYS.forEach(([k, d]) => {
+      expect(typeof k).toBe('string')
+      expect(typeof d).toBe('string')
+    })
+  })
+
+  it('documents Ctrl/Cmd+L as non-destructive redraw', () => {
+    const hotkey = HOTKEYS.find(([k]) => k.endsWith('+L'))
+    expect(hotkey).toBeDefined()
+    expect(hotkey?.[1]).toBe('redraw / repaint')
+  })
+
+  it('TOOL_VERBS maps known tools (verb-only, no emoji)', () => {
+    expect(TOOL_VERBS.terminal).toBe('terminal')
+    expect(TOOL_VERBS.read_file).toBe('reading')
+  })
+
+  it('INTERPOLATION_RE matches {!cmd}', () => {
+    INTERPOLATION_RE.lastIndex = 0
+    expect(INTERPOLATION_RE.test('{!date}')).toBe(true)
+
+    INTERPOLATION_RE.lastIndex = 0
+    expect(INTERPOLATION_RE.test('plain')).toBe(false)
+  })
+
+  it('ROLE produces glyph/body/prefix per role', () => {
+    for (const role of ['assistant', 'system', 'tool', 'user'] as const) {
+      expect(ROLE[role](DEFAULT_THEME)).toHaveProperty('glyph')
+    }
+  })
+})