@sushanglewis/lincoln 1.5.0 → 1.5.1

package/framework/tools/lincoln-installer/tests/components/UpdateApp.test.tsx

@@ -0,0 +1,170 @@
+import { describe, expect, test, vi, afterEach } from 'vitest'
+import { render } from 'ink-testing-library'
+import { UpdateApp } from '../../src/components/UpdateApp'
+import * as updateReleaseModule from '../../src/utils/updateRelease'
+
+async function tick() {
+  return new Promise((resolve) => setTimeout(resolve, 0))
+}
+
+describe('UpdateApp', () => {
+  afterEach(() => {
+    vi.restoreAllMocks()
+  })
+
+  test('renders welcome and starts checking', async () => {
+    vi.spyOn(updateReleaseModule, 'updateRelease').mockResolvedValue({
+      success: true,
+      fromVersion: '1.2.0',
+      toVersion: '1.2.0',
+      updated: [],
+      preserved: [],
+    })
+
+    const { lastFrame } = render(<UpdateApp root="/tmp/proj" repo="sushanglewis/Lincoln" dryRun={false} />)
+    await tick()
+    expect(lastFrame() ?? '').toMatch(/Lincoln Update|up to date/)
+    expect(updateReleaseModule.updateRelease).toHaveBeenCalledWith({
+      root: '/tmp/proj',
+      repo: 'sushanglewis/Lincoln',
+      dryRun: true,
+    })
+  })
+
+  test('shows up-to-date when versions match', async () => {
+    vi.spyOn(updateReleaseModule, 'updateRelease').mockResolvedValue({
+      success: true,
+      fromVersion: '1.3.0',
+      toVersion: '1.3.0',
+      updated: [],
+      preserved: [],
+    })
+
+    const { lastFrame } = render(<UpdateApp root="/tmp/proj" repo="sushanglewis/Lincoln" dryRun={false} />)
+
+    await vi.waitFor(() => expect(lastFrame() ?? '').toContain('up to date'), {
+      timeout: 2000,
+    })
+  })
+
+  test('shows confirm screen when update is available', async () => {
+    vi.spyOn(updateReleaseModule, 'updateRelease').mockResolvedValueOnce({
+      success: true,
+      fromVersion: '1.2.0',
+      toVersion: '1.3.0',
+      updated: [],
+      preserved: [],
+    })
+
+    const { lastFrame } = render(<UpdateApp root="/tmp/proj" repo="sushanglewis/Lincoln" dryRun={false} />)
+
+    await vi.waitFor(() => expect(lastFrame() ?? '').toContain('Update available'), {
+      timeout: 2000,
+    })
+  })
+
+  test('starts update on confirm and shows result', async () => {
+    const updateSpy = vi
+      .spyOn(updateReleaseModule, 'updateRelease')
+      .mockResolvedValueOnce({
+        success: true,
+        fromVersion: '1.2.0',
+        toVersion: '1.3.0',
+        updated: [],
+        preserved: [],
+      })
+      .mockResolvedValueOnce({
+        success: true,
+        fromVersion: '1.2.0',
+        toVersion: '1.3.0',
+        updated: ['README.md'],
+        preserved: ['.context'],
+      })
+
+    const { lastFrame, stdin } = render(
+      <UpdateApp root="/tmp/proj" repo="sushanglewis/Lincoln" dryRun={false} />
+    )
+
+    await vi.waitFor(() => expect(lastFrame() ?? '').toContain('Update available'), {
+      timeout: 2000,
+    })
+
+    stdin.write('\r')
+    await tick()
+
+    await vi.waitFor(() => expect(lastFrame() ?? '').toContain('Update complete'), {
+      timeout: 2000,
+    })
+
+    expect(updateSpy).toHaveBeenCalledTimes(2)
+    expect(updateSpy).toHaveBeenLastCalledWith({
+      root: '/tmp/proj',
+      repo: 'sushanglewis/Lincoln',
+      dryRun: false,
+    })
+  })
+
+  test('displays error when update fails', async () => {
+    vi.spyOn(updateReleaseModule, 'updateRelease').mockResolvedValue({
+      success: false,
+      updated: [],
+      preserved: [],
+      error: 'network error',
+    })
+
+    const { lastFrame } = render(<UpdateApp root="/tmp/proj" repo="sushanglewis/Lincoln" dryRun={false} />)
+
+    await vi.waitFor(() => expect(lastFrame() ?? '').toContain('Update failed'), {
+      timeout: 2000,
+    })
+    expect(lastFrame() ?? '').toContain('network error')
+  })
+
+  test('displays error when apply throws after confirmation', async () => {
+    const updateSpy = vi
+      .spyOn(updateReleaseModule, 'updateRelease')
+      .mockResolvedValueOnce({
+        success: true,
+        fromVersion: '1.2.0',
+        toVersion: '1.3.0',
+        updated: [],
+        preserved: [],
+      })
+      .mockRejectedValueOnce(new Error('apply failed'))
+
+    const { lastFrame, stdin } = render(
+      <UpdateApp root="/tmp/proj" repo="sushanglewis/Lincoln" dryRun={false} />
+    )
+
+    await vi.waitFor(() => expect(lastFrame() ?? '').toContain('Update available'), {
+      timeout: 2000,
+    })
+
+    stdin.write('\r')
+    await tick()
+
+    await vi.waitFor(() => expect(lastFrame() ?? '').toContain('Update failed'), {
+      timeout: 2000,
+    })
+    expect(lastFrame() ?? '').toContain('apply failed')
+    expect(updateSpy).toHaveBeenCalledTimes(2)
+  })
+
+  test('shows dry-run result when dryRun is true', async () => {
+    vi.spyOn(updateReleaseModule, 'updateRelease').mockResolvedValue({
+      success: true,
+      fromVersion: '1.2.0',
+      toVersion: '1.3.0',
+      updated: [],
+      preserved: [],
+    })
+
+    const { lastFrame } = render(<UpdateApp root="/tmp/proj" repo="sushanglewis/Lincoln" dryRun />)
+
+    await vi.waitFor(() => expect(lastFrame() ?? '').toContain('Dry run'), {
+      timeout: 2000,
+    })
+    expect(lastFrame() ?? '').toContain('1.2.0 → 1.3.0')
+  })
+
+})

package/framework/tools/lincoln-installer/tests/components/screens.test.tsx

@@ -0,0 +1,310 @@
+import React from 'react'
+import { describe, expect, test, vi } from 'vitest'
+import { render } from 'ink-testing-library'
+import { WelcomeScreen } from '../../src/components/WelcomeScreen'
+import { HarnessSelectScreen } from '../../src/components/HarnessSelectScreen'
+import { OptionsScreen } from '../../src/components/OptionsScreen'
+import { SummaryScreen } from '../../src/components/SummaryScreen'
+import { ProgressScreen } from '../../src/components/ProgressScreen'
+import { ResultScreen } from '../../src/components/ResultScreen'
+import { SelectMenu } from '../../src/components/SelectMenu'
+import type { HarnessInfo } from '../../src/types'
+
+async function tick() {
+  return new Promise((resolve) => setTimeout(resolve, 0))
+}
+
+describe('WelcomeScreen', () => {
+  test('renders welcome message', () => {
+    const { lastFrame } = render(<WelcomeScreen onStart={() => {}} />)
+    expect(lastFrame()).toContain('Welcome to Lincoln')
+  })
+
+  test('calls onStart on enter', async () => {
+    const onStart = vi.fn()
+    const { stdin } = render(<WelcomeScreen onStart={onStart} />)
+    await tick()
+    stdin.write('\r')
+    await tick()
+    expect(onStart).toHaveBeenCalled()
+  })
+
+  test('ignores non-enter keys', async () => {
+    const onStart = vi.fn()
+    const { stdin } = render(<WelcomeScreen onStart={onStart} />)
+    await tick()
+    stdin.write('x')
+    await tick()
+    expect(onStart).not.toHaveBeenCalled()
+  })
+})
+
+describe('SelectMenu', () => {
+  test('selects item with enter in single mode', async () => {
+    const onSelect = vi.fn()
+    const onConfirm = vi.fn()
+    const { stdin } = render(
+      <SelectMenu
+        title="Choose"
+        items={[
+          { label: 'One', value: 'one' },
+          { label: 'Two', value: 'two' },
+        ]}
+        selected={[]}
+        onSelect={onSelect}
+        onConfirm={onConfirm}
+      />
+    )
+    await tick()
+    stdin.write('\r')
+    await tick()
+    expect(onSelect).toHaveBeenCalledWith('one')
+    expect(onConfirm).toHaveBeenCalledWith('one')
+  })
+
+  test('toggles item with space in multiple mode', async () => {
+    const onSelect = vi.fn()
+    const { stdin } = render(
+      <SelectMenu
+        title="Choose"
+        items={[
+          { label: 'One', value: 'one' },
+          { label: 'Two', value: 'two' },
+        ]}
+        selected={[]}
+        multiple
+        onSelect={onSelect}
+        onConfirm={() => {}}
+      />
+    )
+    await tick()
+    stdin.write(' ')
+    await tick()
+    expect(onSelect).toHaveBeenCalledWith('one')
+  })
+
+  test('navigates down and selects second item', async () => {
+    const onSelect = vi.fn()
+    const onConfirm = vi.fn()
+    const { stdin } = render(
+      <SelectMenu
+        title="Choose"
+        items={[
+          { label: 'One', value: 'one' },
+          { label: 'Two', value: 'two' },
+        ]}
+        selected={[]}
+        onSelect={onSelect}
+        onConfirm={onConfirm}
+      />
+    )
+    await tick()
+    stdin.write('\x1b[B')
+    await tick()
+    stdin.write('\r')
+    await tick()
+    expect(onSelect).toHaveBeenCalledWith('two')
+    expect(onConfirm).toHaveBeenCalledWith('two')
+  })
+})
+
+describe('HarnessSelectScreen', () => {
+  const harnesses: HarnessInfo[] = [
+    { id: 'claude-code', name: 'Claude Code', description: 'Anthropic', installed: false },
+    { id: 'codex', name: 'Codex', description: 'OpenAI', installed: true },
+  ]
+
+  test('renders harness options and confirms selection', async () => {
+    const onConfirm = vi.fn()
+    const { lastFrame, stdin } = render(
+      <HarnessSelectScreen
+        harnesses={harnesses}
+        selected={['codex']}
+        onConfirm={onConfirm}
+      />
+    )
+    await tick()
+    expect(lastFrame()).toContain('Claude Code')
+    expect(lastFrame()).toContain('Codex')
+    stdin.write(' ')
+    await tick()
+    stdin.write('\r')
+    await tick()
+    expect(onConfirm).toHaveBeenCalledWith(expect.arrayContaining(['codex', 'claude-code']))
+  })
+})
+
+describe('OptionsScreen', () => {
+  test('toggles option with space and confirms', async () => {
+    const onConfirm = vi.fn()
+    const { stdin } = render(
+      <OptionsScreen
+        options={{ installRecordingDeps: false, runBenchmark: false }}
+        onConfirm={onConfirm}
+      />
+    )
+    await tick()
+    stdin.write(' ')
+    await tick()
+    stdin.write('\r')
+    await tick()
+    expect(onConfirm).toHaveBeenCalledWith({
+      installRecordingDeps: true,
+      runBenchmark: false,
+    })
+  })
+
+  test('wraps cursor with up and down arrows', async () => {
+    const { lastFrame, stdin } = render(
+      <OptionsScreen
+        options={{ installRecordingDeps: false, runBenchmark: false }}
+        onConfirm={() => {}}
+      />
+    )
+    await tick()
+    stdin.write('\x1b[A')
+    await tick()
+    expect(lastFrame()).toContain('Enable benchmark tooling')
+    stdin.write('\x1b[B')
+    await tick()
+    stdin.write('\x1b[B')
+    await tick()
+    expect(lastFrame()).toContain('Enable benchmark tooling')
+  })
+})
+
+describe('SummaryScreen', () => {
+  test('renders summary and confirms', async () => {
+    const onConfirm = vi.fn()
+    const onCancel = vi.fn()
+    const { lastFrame, stdin } = render(
+      <SummaryScreen
+        root="/tmp/proj"
+        selectedHarnesses={['claude-code']}
+        harnesses={[
+          { id: 'claude-code', name: 'Claude Code', description: '', installed: false },
+        ]}
+        options={{ installRecordingDeps: false, runBenchmark: true }}
+        dryRun={false}
+        onConfirm={onConfirm}
+        onCancel={onCancel}
+      />
+    )
+    await tick()
+    expect(lastFrame()).toContain('/tmp/proj')
+    expect(lastFrame()).toContain('Claude Code')
+    stdin.write('\r')
+    await tick()
+    expect(onConfirm).toHaveBeenCalled()
+  })
+
+  test('cancels on escape', async () => {
+    const onCancel = vi.fn()
+    const { stdin } = render(
+      <SummaryScreen
+        root="/tmp/proj"
+        selectedHarnesses={[]}
+        harnesses={[]}
+        options={{ installRecordingDeps: false, runBenchmark: false }}
+        dryRun={true}
+        onConfirm={() => {}}
+        onCancel={onCancel}
+      />
+    )
+    await tick()
+    stdin.write('\x1b')
+    await tick()
+    expect(onCancel).toHaveBeenCalled()
+  })
+})
+
+describe('ProgressScreen', () => {
+  test('renders completed and current steps', () => {
+    const { lastFrame } = render(
+      <ProgressScreen
+        currentStep="install-clis"
+        results={[
+          { step: 'check', success: true },
+          { step: 'install-skills', success: true },
+        ]}
+      />
+    )
+    expect(lastFrame()).toContain('check')
+    expect(lastFrame()).toContain('install-clis')
+  })
+})
+
+describe('ResultScreen', () => {
+  test('renders success when all steps pass', () => {
+    const { lastFrame } = render(
+      <ResultScreen
+        results={[{ step: 'check', success: true }]}
+        onFinish={() => {}}
+      />
+    )
+    expect(lastFrame()).toContain('complete')
+  })
+
+  test('renders failure for failed step', () => {
+    const { lastFrame } = render(
+      <ResultScreen
+        results={[{ step: 'check', success: false, error: 'oops' }]}
+        onFinish={() => {}}
+      />
+    )
+    expect(lastFrame()).toContain('incomplete')
+    expect(lastFrame()).toContain('oops')
+  })
+})
+
+describe('SelectMenu extras', () => {
+  test('calls onCancel on escape', async () => {
+    const onCancel = vi.fn()
+    const { stdin } = render(
+      <SelectMenu
+        title="Choose"
+        items={[{ label: 'One', value: 'one' }]}
+        selected={[]}
+        onSelect={() => {}}
+        onConfirm={() => {}}
+        onCancel={onCancel}
+      />
+    )
+    await tick()
+    stdin.write('\x1b')
+    await tick()
+    expect(onCancel).toHaveBeenCalled()
+  })
+
+  test('navigates up and wraps cursor', async () => {
+    const { lastFrame, stdin } = render(
+      <SelectMenu
+        title="Choose"
+        items={[
+          { label: 'One', value: 'one' },
+          { label: 'Two', value: 'two' },
+        ]}
+        selected={[]}
+        onSelect={() => {}}
+        onConfirm={() => {}}
+      />
+    )
+    await tick()
+    stdin.write('\x1b[A')
+    await tick()
+    expect(lastFrame()).toContain('> ○ Two')
+  })
+})
+
+describe('ResultScreen extras', () => {
+  test('calls onFinish on enter', async () => {
+    const onFinish = vi.fn()
+    const { stdin } = render(
+      <ResultScreen results={[{ step: 'check', success: true }]} onFinish={onFinish} />
+    )
+    await tick()
+    stdin.write('\r')
+    await tick()
+    expect(onFinish).toHaveBeenCalled()
+  })
+})

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

@@ -0,0 +1,66 @@
+import { describe, expect, test } from 'vitest'
+import { parseArgs } from '../../src/config/args'
+
+describe('parseArgs', () => {
+  test('returns defaults for empty argv', () => {
+    const args = parseArgs([])
+    expect(args.root).toBe('.')
+    expect(args.harness).toEqual([])
+    expect(args.yes).toBe(false)
+    expect(args.dryRun).toBe(false)
+    expect(args.noTui).toBe(false)
+    expect(args.format).toBe('human')
+    expect(args.help).toBe(false)
+  })
+
+  test('parses --root', () => {
+    const args = parseArgs(['--root', '/tmp/proj'])
+    expect(args.root).toBe('/tmp/proj')
+  })
+
+  test('throws when --root is missing value', () => {
+    expect(() => parseArgs(['--root'])).toThrow('Missing value for --root')
+  })
+
+  test('throws when --root value is another flag', () => {
+    expect(() => parseArgs(['--root', '--yes'])).toThrow('Missing value for --root')
+  })
+
+  test('collects multiple --harness values', () => {
+    const args = parseArgs(['--harness', 'claude-code', '--harness', 'codex'])
+    expect(args.harness).toEqual(['claude-code', 'codex'])
+  })
+
+  test('throws when --harness is missing value', () => {
+    expect(() => parseArgs(['--harness'])).toThrow('Missing value for --harness')
+  })
+
+  test('parses boolean flags', () => {
+    const args = parseArgs(['--yes', '--dry-run', '--no-tui'])
+    expect(args.yes).toBe(true)
+    expect(args.dryRun).toBe(true)
+    expect(args.noTui).toBe(true)
+  })
+
+  test('parses --format json', () => {
+    const args = parseArgs(['--format', 'json'])
+    expect(args.format).toBe('json')
+  })
+
+  test('throws on invalid format', () => {
+    expect(() => parseArgs(['--format', 'xml'])).toThrow("Invalid value for --format: xml")
+  })
+
+  test('throws when --format is missing value', () => {
+    expect(() => parseArgs(['--format'])).toThrow('Missing value for --format')
+  })
+
+  test('sets help for --help and -h', () => {
+    expect(parseArgs(['--help']).help).toBe(true)
+    expect(parseArgs(['-h']).help).toBe(true)
+  })
+
+  test('throws on unknown argument', () => {
+    expect(() => parseArgs(['--unknown'])).toThrow('Unknown argument: --unknown')
+  })
+})

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

@@ -0,0 +1,75 @@
+import { mkdtempSync, mkdirSync, writeFileSync, rmSync } from 'node:fs'
+import { tmpdir } from 'node:os'
+import { resolve, join } from 'node:path'
+import { describe, expect, test, afterEach } from 'vitest'
+import { resolveConfig } from '../../src/config/resolveConfig'
+import type { ParsedArgs } from '../../src/config/args'
+
+function makeProjectDir(): string {
+  const root = mkdtempSync(join(tmpdir(), 'lincoln-'))
+  const scriptsDir = join(root, 'scripts')
+  mkdirSync(scriptsDir)
+  writeFileSync(join(scriptsDir, 'lincoln-setup.py'), '')
+  return root
+}
+
+function makeArgs(overrides: Partial<ParsedArgs> = {}, root = makeProjectDir()): ParsedArgs {
+  return {
+    root,
+    harness: [],
+    yes: false,
+    dryRun: false,
+    noTui: false,
+    format: 'human',
+    help: false,
+    ...overrides,
+  }
+}
+
+describe('resolveConfig', () => {
+  const dirs: string[] = []
+
+  afterEach(() => {
+    for (const dir of dirs) {
+      rmSync(dir, { recursive: true, force: true })
+    }
+    dirs.length = 0
+  })
+
+  test('resolves root to absolute path', () => {
+    const root = makeProjectDir()
+    dirs.push(root)
+    const config = resolveConfig(makeArgs({ root }))
+    expect(config.root).toBe(resolve(root))
+  })
+
+  test('uses provided harnesses', () => {
+    const root = makeProjectDir()
+    dirs.push(root)
+    const config = resolveConfig(makeArgs({ root, harness: ['claude-code'] }))
+    expect(config.harnesses).toEqual(['claude-code'])
+  })
+
+  test('passes boolean flags through', () => {
+    const root = makeProjectDir()
+    dirs.push(root)
+    const config = resolveConfig(makeArgs({ root, yes: true, dryRun: true, format: 'json' }))
+    expect(config.yes).toBe(true)
+    expect(config.dryRun).toBe(true)
+    expect(config.format).toBe('json')
+  })
+
+  test('throws when root does not exist', () => {
+    expect(() => resolveConfig(makeArgs({ root: '/does/not/exist' }, '/does/not/exist'))).toThrow(
+      'Project root does not exist or is not a directory'
+    )
+  })
+
+  test('throws when setup script is missing', () => {
+    const root = mkdtempSync(join(tmpdir(), 'lincoln-'))
+    dirs.push(root)
+    expect(() => resolveConfig(makeArgs({ root }, root))).toThrow(
+      'Lincoln setup script not found'
+    )
+  })
+})

package/framework/tools/lincoln-installer/tests/config/updateArgs.test.ts

@@ -0,0 +1,52 @@
+import { describe, expect, test } from 'vitest'
+import { parseUpdateArgs } from '../../src/config/updateArgs'
+
+describe('parseUpdateArgs', () => {
+  test('returns defaults for empty argv', () => {
+    const args = parseUpdateArgs([])
+    expect(args.root).toBe('.')
+    expect(args.repo).toBe('sushanglewis/Lincoln')
+    expect(args.dryRun).toBe(false)
+    expect(args.noTui).toBe(false)
+    expect(args.format).toBe('human')
+    expect(args.help).toBe(false)
+  })
+
+  test('parses --root', () => {
+    const args = parseUpdateArgs(['--root', '/tmp/proj'])
+    expect(args.root).toBe('/tmp/proj')
+  })
+
+  test('throws when --root value is missing', () => {
+    expect(() => parseUpdateArgs(['--root'])).toThrow('Missing value for --root')
+  })
+
+  test('parses --repo', () => {
+    const args = parseUpdateArgs(['--repo', 'owner/repo'])
+    expect(args.repo).toBe('owner/repo')
+  })
+
+  test('parses --dry-run and --no-tui', () => {
+    const args = parseUpdateArgs(['--dry-run', '--no-tui'])
+    expect(args.dryRun).toBe(true)
+    expect(args.noTui).toBe(true)
+  })
+
+  test('parses --format json', () => {
+    const args = parseUpdateArgs(['--format', 'json'])
+    expect(args.format).toBe('json')
+  })
+
+  test('throws on invalid --format', () => {
+    expect(() => parseUpdateArgs(['--format', 'xml'])).toThrow('Invalid value for --format: xml')
+  })
+
+  test('sets help for --help and -h', () => {
+    expect(parseUpdateArgs(['--help']).help).toBe(true)
+    expect(parseUpdateArgs(['-h']).help).toBe(true)
+  })
+
+  test('throws on invalid repository slug', () => {
+    expect(() => parseUpdateArgs(['--repo', 'invalid'])).toThrow('Invalid repository slug')
+  })
+})