@sushanglewis/lincoln 1.5.0 → 1.5.2

package/framework/tools/lincoln-installer/package.json

@@ -0,0 +1,53 @@
+{
+  "name": "lincoln-install",
+  "version": "1.5.2",
+  "description": "Terminal TUI installer for the Lincoln AI-Native R&D workflow system",
+  "type": "module",
+  "main": "dist/main.js",
+  "module": "dist/main.js",
+  "types": "dist/main.d.ts",
+  "bin": {
+    "lincoln-install": "dist/main.js",
+    "lincoln-update": "dist/update-main.js"
+  },
+  "files": [
+    "dist"
+  ],
+  "scripts": {
+    "build": "tsup",
+    "dev": "tsup --watch",
+    "test": "vitest run --coverage",
+    "test:watch": "vitest",
+    "typecheck": "tsc --noEmit",
+    "typecheck:tests": "tsc -p tsconfig.tests.json",
+    "lint": "echo 'lint not configured'"
+  },
+  "dependencies": {
+    "ink": "^5.2.0",
+    "js-yaml": "^4.1.0",
+    "react": "^18.3.1",
+    "tar": "^7.4.3"
+  },
+  "devDependencies": {
+    "@types/js-yaml": "^4.0.9",
+    "@types/node": "^22.15.0",
+    "@types/react": "^18.3.12",
+    "@types/tar": "^6.1.13",
+    "@vitest/coverage-v8": "^4.1.10",
+    "ink-testing-library": "^4.0.0",
+    "tsup": "^8.5.0",
+    "typescript": "^5.8.3",
+    "vitest": "^4.1.9"
+  },
+  "engines": {
+    "node": ">=20.0.0"
+  },
+  "keywords": [
+    "lincoln",
+    "installer",
+    "tui",
+    "claude-code",
+    "ai-workflow"
+  ],
+  "license": "MIT"
+}

package/framework/tools/lincoln-installer/src/cli.tsx

@@ -0,0 +1,63 @@
+#!/usr/bin/env node
+import { Box, Text } from 'ink'
+import React from 'react'
+
+import { parseArgs } from './config/args'
+import { resolveConfig } from './config/resolveConfig'
+import { InstallerApp } from './components/InstallerApp'
+
+export interface AppProps {
+  args: ReturnType<typeof parseArgs>
+  config: ReturnType<typeof resolveConfig>
+}
+
+export function App({ args, config }: AppProps) {
+  if (args.help) {
+    return (
+      <Box flexDirection="column" padding={1}>
+        <Text bold>lincoln-install</Text>
+        <Text>Terminal TUI installer for Lincoln.</Text>
+        <Text />
+        <Text bold>Usage:</Text>
+        <Text>  npx lincoln-install [options]</Text>
+        <Text />
+        <Text bold>Options:</Text>
+        <Text>  --root        Project root directory (default: current dir)</Text>
+        <Text>  --harness     Target harness to generate (repeatable)</Text>
+        <Text>  --yes         Auto-confirm all prompts</Text>
+        <Text>  --dry-run     Show what would be done without executing</Text>
+        <Text>  --no-tui      Print resolved config as JSON and exit</Text>
+        <Text>  --format      Output format: human|json (default: human)</Text>
+        <Text>  --help, -h    Show this help message</Text>
+      </Box>
+    )
+  }
+
+  return <InstallerApp config={config} />
+}
+
+export async function main(argv: string[] = process.argv.slice(2)): Promise<void> {
+  try {
+    const args = parseArgs(argv)
+
+    if (args.help) {
+      const { render } = await import('ink')
+      render(<App args={args} config={{ root: process.cwd(), harnesses: [], yes: false, dryRun: false, format: args.format }} />)
+      return
+    }
+
+    const config = resolveConfig(args)
+
+    if (args.noTui) {
+      console.log(JSON.stringify(config, null, 2))
+      return
+    }
+
+    const { render } = await import('ink')
+    render(<App args={args} config={config} />)
+  } catch (err) {
+    const message = err instanceof Error ? err.message : String(err)
+    console.error(`Error: ${message}`)
+    process.exitCode = 1
+  }
+}

package/framework/tools/lincoln-installer/src/components/HarnessSelectScreen.tsx

@@ -0,0 +1,43 @@
+import { Box, Text } from 'ink'
+import React, { useState } from 'react'
+
+import type { HarnessInfo } from '../types'
+import { SelectMenu } from './SelectMenu'
+
+export interface HarnessSelectScreenProps {
+  harnesses: HarnessInfo[]
+  selected: string[]
+  onConfirm: (selected: string[]) => void
+}
+
+export function HarnessSelectScreen({
+  harnesses,
+  selected: initialSelected,
+  onConfirm,
+}: HarnessSelectScreenProps) {
+  const [selected, setSelected] = useState(initialSelected)
+  const items = harnesses.map((h) => ({
+    label: `${h.name} ${h.installed ? '(detected)' : ''} - ${h.description}`,
+    value: h.id,
+  }))
+
+  const handleSelect = (value: string) => {
+    setSelected((prev) =>
+      prev.includes(value) ? prev.filter((v) => v !== value) : [...prev, value]
+    )
+  }
+
+  return (
+    <Box flexDirection="column" padding={1}>
+      <Text bold>Select agent harnesses</Text>
+      <Text dimColor>Choose one or more targets for Lincoln.</Text>
+      <SelectMenu
+        items={items}
+        selected={selected}
+        multiple
+        onSelect={handleSelect}
+        onConfirm={() => onConfirm(selected)}
+      />
+    </Box>
+  )
+}

package/framework/tools/lincoln-installer/src/components/InstallerApp.tsx

@@ -0,0 +1,98 @@
+import { Box, Text } from 'ink'
+import React, { useState, useEffect } from 'react'
+
+import type { InstallerConfig } from '../config/resolveConfig'
+import type { HarnessInfo } from '../types'
+import { detectHarnesses } from '../utils/detectHarness'
+import { useSetup, type SetupPhase } from '../hooks/useSetup'
+import { HarnessSelectScreen } from './HarnessSelectScreen'
+import { OptionsScreen, type InstallerOptions } from './OptionsScreen'
+import { ProgressScreen } from './ProgressScreen'
+import { ResultScreen } from './ResultScreen'
+import { SummaryScreen } from './SummaryScreen'
+import { WelcomeScreen } from './WelcomeScreen'
+
+export interface InstallerAppProps {
+  config: InstallerConfig
+}
+
+export function InstallerApp({ config }: InstallerAppProps) {
+  const [phase, setPhase] = useState<SetupPhase>('welcome')
+  const [harnesses, setHarnesses] = useState<HarnessInfo[]>([])
+  const [selectedHarnesses, setSelectedHarnesses] = useState<string[]>([])
+  const [options, setOptions] = useState<InstallerOptions>({
+    installRecordingDeps: false,
+    runBenchmark: false,
+  })
+
+  const { isRunning, results, currentStep, error, startSetup } = useSetup()
+
+  useEffect(() => {
+    const detected = detectHarnesses(config.root)
+    setHarnesses(detected)
+    setSelectedHarnesses(detected.filter((h) => h.installed).map((h) => h.id))
+  }, [config.root])
+
+  useEffect(() => {
+    if (!isRunning && phase === 'running') {
+      setPhase('result')
+    }
+  }, [isRunning, phase])
+
+  const handleHarnessConfirm = (selected: string[]) => {
+    setSelectedHarnesses(selected)
+    setPhase('options')
+  }
+
+  const handleOptionsConfirm = (opts: InstallerOptions) => {
+    setOptions(opts)
+    setPhase('summary')
+  }
+
+  const handleSummaryConfirm = () => {
+    startSetup({
+      root: config.root,
+      harnesses: selectedHarnesses,
+      yes: config.yes,
+      dryRun: config.dryRun,
+    })
+    setPhase('running')
+  }
+
+  const handleCancel = () => {
+    process.exit(0)
+  }
+
+  switch (phase) {
+    case 'welcome':
+      return <WelcomeScreen onStart={() => setPhase('harness')} />
+    case 'harness':
+      return (
+        <HarnessSelectScreen
+          harnesses={harnesses}
+          selected={selectedHarnesses}
+          onConfirm={handleHarnessConfirm}
+        />
+      )
+    case 'options':
+      return <OptionsScreen options={options} onConfirm={handleOptionsConfirm} />
+    case 'summary':
+      return (
+        <SummaryScreen
+          root={config.root}
+          selectedHarnesses={selectedHarnesses}
+          harnesses={harnesses}
+          options={options}
+          dryRun={config.dryRun}
+          onConfirm={handleSummaryConfirm}
+          onCancel={handleCancel}
+        />
+      )
+    case 'running':
+      return <ProgressScreen currentStep={currentStep} results={results} />
+    case 'result':
+      return <ResultScreen results={results} error={error} onFinish={() => process.exit(0)} />
+    default:
+      return <Text>Unknown phase</Text>
+  }
+}

package/framework/tools/lincoln-installer/src/components/OptionsScreen.tsx

@@ -0,0 +1,56 @@
+import { Box, Text, useInput } from 'ink'
+import React, { useState } from 'react'
+
+export interface InstallerOptions {
+  installRecordingDeps: boolean
+  runBenchmark: boolean
+}
+
+export interface OptionsScreenProps {
+  options: InstallerOptions
+  onConfirm: (options: InstallerOptions) => void
+}
+
+const OPTIONS: { key: keyof InstallerOptions; label: string }[] = [
+  {
+    key: 'installRecordingDeps',
+    label: 'Install optional recording dependencies (ffmpeg, faster-whisper)',
+  },
+  { key: 'runBenchmark', label: 'Enable benchmark tooling' },
+]
+
+export function OptionsScreen({ options: initialOptions, onConfirm }: OptionsScreenProps) {
+  const [cursor, setCursor] = useState(0)
+  const [options, setOptions] = useState(initialOptions)
+
+  useInput((input, key) => {
+    if (key.upArrow) {
+      setCursor((c) => (c > 0 ? c - 1 : OPTIONS.length - 1))
+    } else if (key.downArrow) {
+      setCursor((c) => (c < OPTIONS.length - 1 ? c + 1 : 0))
+    } else if (input === ' ') {
+      const key = OPTIONS[cursor].key
+      setOptions((o) => ({ ...o, [key]: !o[key] }))
+    } else if (key.return) {
+      onConfirm(options)
+    }
+  })
+
+  return (
+    <Box flexDirection="column" padding={1}>
+      <Text bold>Options</Text>
+      {OPTIONS.map((option, index) => {
+        const isCursor = index === cursor
+        const enabled = options[option.key]
+        return (
+          <Text key={option.key} color={isCursor ? 'cyan' : undefined}>
+            {isCursor ? '> ' : '  '}
+            [{enabled ? 'x' : ' '}] {option.label}
+          </Text>
+        )
+      })}
+      <Text dimColor></Text>
+      <Text dimColor>Space to toggle, Enter to confirm</Text>
+    </Box>
+  )
+}

package/framework/tools/lincoln-installer/src/components/ProgressScreen.tsx

@@ -0,0 +1,25 @@
+import { Box, Text } from 'ink'
+import React from 'react'
+
+import type { StepResult } from '../hooks/useSetup'
+
+export interface ProgressScreenProps {
+  currentStep: string
+  results: StepResult[]
+}
+
+export function ProgressScreen({ currentStep, results }: ProgressScreenProps) {
+  return (
+    <Box flexDirection="column" padding={1}>
+      <Text bold>Installing Lincoln...</Text>
+      {results.map((result) => (
+        <Text key={result.step}>
+          {result.success ? '✅' : '❌'} {result.step}
+        </Text>
+      ))}
+      {currentStep && !results.some((r) => r.step === currentStep && r.success) && (
+        <Text color="cyan">⏳ {currentStep}...</Text>
+      )}
+    </Box>
+  )
+}

package/framework/tools/lincoln-installer/src/components/ResultScreen.tsx

@@ -0,0 +1,40 @@
+import { Box, Text, useInput } from 'ink'
+import React from 'react'
+
+import type { StepResult } from '../hooks/useSetup'
+
+export interface ResultScreenProps {
+  results: StepResult[]
+  error?: string
+  onFinish: () => void
+}
+
+export function ResultScreen({ results, error, onFinish }: ResultScreenProps) {
+  useInput((_, key) => {
+    if (key.return || key.escape) {
+      onFinish()
+    }
+  })
+
+  const allSuccess = results.length > 0 && results.every((r) => r.success)
+
+  return (
+    <Box flexDirection="column" padding={1}>
+      {allSuccess ? (
+        <Text bold color="green">✅ Lincoln installation complete!</Text>
+      ) : (
+        <Text bold color="red">❌ Installation incomplete</Text>
+      )}
+      {error && <Text color="red">{error}</Text>}
+      {results.map((result) => (
+        <Box key={result.step} flexDirection="column" marginBottom={1}>
+          <Text>
+            {result.success ? '✅' : '❌'} {result.step}
+          </Text>
+          {result.error && <Text color="red">  {result.error}</Text>}
+        </Box>
+      ))}
+      <Text dimColor>Press Enter or Esc to exit.</Text>
+    </Box>
+  )
+}

package/framework/tools/lincoln-installer/src/components/SelectMenu.tsx

@@ -0,0 +1,73 @@
+import { Box, Text, useInput } from 'ink'
+import React, { useState } from 'react'
+
+export interface SelectMenuItem {
+  label: string
+  value: string
+}
+
+export interface SelectMenuProps {
+  title?: string
+  items: SelectMenuItem[]
+  selected: string[]
+  multiple?: boolean
+  onSelect: (value: string) => void
+  onConfirm: (value?: string) => void
+  onCancel?: () => void
+}
+
+export function SelectMenu({
+  title,
+  items,
+  selected,
+  multiple = false,
+  onSelect,
+  onConfirm,
+  onCancel,
+}: SelectMenuProps) {
+  const [cursor, setCursor] = useState(0)
+
+  useInput((input, key) => {
+    if (key.upArrow) {
+      setCursor((c) => (c > 0 ? c - 1 : items.length - 1))
+    } else if (key.downArrow) {
+      setCursor((c) => (c < items.length - 1 ? c + 1 : 0))
+    } else if (key.return) {
+      if (multiple) {
+        onConfirm()
+      } else {
+        const value = items[cursor]?.value
+        if (value) {
+          onSelect(value)
+          onConfirm(value)
+        }
+      }
+    } else if (key.escape) {
+      onCancel?.()
+    } else if (input === ' ') {
+      const value = items[cursor]?.value
+      if (value) {
+        onSelect(value)
+      }
+    }
+  })
+
+  return (
+    <Box flexDirection="column">
+      {title ? <Text bold>{title}</Text> : null}
+      {items.map((item, index) => {
+        const isCursor = index === cursor
+        const isSelected = selected.includes(item.value)
+        const marker = multiple ? (isSelected ? '[x]' : '[ ]') : isSelected ? '●' : '○'
+        return (
+          <Text key={item.value} color={isCursor ? 'cyan' : undefined}>
+            {isCursor ? '> ' : '  '}
+            {marker} {item.label}
+          </Text>
+        )
+      })}
+      <Text dimColor></Text>
+      <Text dimColor>{multiple ? 'Space to select, Enter to confirm' : '↑↓ to navigate, Enter to select'}</Text>
+    </Box>
+  )
+}

package/framework/tools/lincoln-installer/src/components/SummaryScreen.tsx

@@ -0,0 +1,49 @@
+import { Box, Text, useInput } from 'ink'
+import React from 'react'
+
+import type { HarnessInfo } from '../types'
+
+export interface SummaryScreenProps {
+  root: string
+  selectedHarnesses: string[]
+  harnesses: HarnessInfo[]
+  options: { installRecordingDeps: boolean; runBenchmark: boolean }
+  dryRun: boolean
+  onConfirm: () => void
+  onCancel: () => void
+}
+
+export function SummaryScreen({
+  root,
+  selectedHarnesses,
+  harnesses,
+  options,
+  dryRun,
+  onConfirm,
+  onCancel,
+}: SummaryScreenProps) {
+  useInput((_, key) => {
+    if (key.return) {
+      onConfirm()
+    } else if (key.escape) {
+      onCancel()
+    }
+  })
+
+  const harnessNames = selectedHarnesses
+    .map((id) => harnesses.find((h) => h.id === id)?.name || id)
+    .join(', ')
+
+  return (
+    <Box flexDirection="column" padding={1}>
+      <Text bold>Summary</Text>
+      <Text>Project root: {root}</Text>
+      <Text>Harnesses: {harnessNames}</Text>
+      <Text>Recording deps: {options.installRecordingDeps ? 'yes' : 'no'}</Text>
+      <Text>Benchmark: {options.runBenchmark ? 'yes' : 'no'}</Text>
+      {dryRun && <Text color="yellow">Dry-run mode: no changes will be made.</Text>}
+      <Text dimColor></Text>
+      <Text>Press Enter to proceed or Esc to cancel.</Text>
+    </Box>
+  )
+}

package/framework/tools/lincoln-installer/src/components/UpdateApp.tsx

@@ -0,0 +1,135 @@
+import { Box, Text, useInput, useApp } from 'ink'
+import React, { useEffect, useState } from 'react'
+
+import { updateRelease, type UpdateResult } from '../utils/updateRelease'
+
+export interface UpdateAppProps {
+  root: string
+  repo: string
+  dryRun: boolean
+}
+
+type UpdatePhase = 'welcome' | 'confirm' | 'running' | 'result'
+
+export function UpdateApp({ root, repo, dryRun }: UpdateAppProps) {
+  const { exit } = useApp()
+  const [phase, setPhase] = useState<UpdatePhase>('welcome')
+  const [result, setResult] = useState<UpdateResult | undefined>(undefined)
+
+  useEffect(() => {
+    async function check(): Promise<void> {
+      const checkResult = await updateRelease({ root, repo, dryRun: true })
+      setResult(checkResult)
+      if (!checkResult.success) {
+        setPhase('result')
+        return
+      }
+      if (checkResult.fromVersion === checkResult.toVersion) {
+        setPhase('result')
+      } else {
+        setPhase(dryRun ? 'result' : 'confirm')
+      }
+    }
+    check()
+  }, [root, repo, dryRun])
+
+  useInput((input, key) => {
+    if (phase === 'confirm' && key.return) {
+      setPhase('running')
+      updateRelease({ root, repo, dryRun })
+        .then((applyResult) => {
+          setResult(applyResult)
+          setPhase('result')
+        })
+        .catch((err) => {
+          setResult({
+            success: false,
+            updated: [],
+            preserved: [],
+            error: err instanceof Error ? err.message : String(err),
+          })
+          setPhase('result')
+        })
+    }
+
+    if (phase === 'result' && key.return) {
+      exit()
+    }
+  })
+
+  if (phase === 'welcome') {
+    return (
+      <Box flexDirection="column" padding={1}>
+        <Text bold>Lincoln Update</Text>
+        <Text dimColor>Checking for the latest release...</Text>
+      </Box>
+    )
+  }
+
+  if (phase === 'confirm' && result?.success) {
+    return (
+      <Box flexDirection="column" padding={1}>
+        <Text bold>Update available</Text>
+        <Text>
+          Current: {result.fromVersion} → Latest: {result.toVersion}
+        </Text>
+        <Text>Press Enter to apply the update, or Ctrl+C to cancel.</Text>
+      </Box>
+    )
+  }
+
+  if (phase === 'running') {
+    return (
+      <Box flexDirection="column" padding={1}>
+        <Text bold>Updating Lincoln...</Text>
+        <Text dimColor>Downloading and applying the latest release.</Text>
+      </Box>
+    )
+  }
+
+  if (!result) {
+    return null
+  }
+
+  return (
+    <Box flexDirection="column" padding={1}>
+      {result.success && result.fromVersion === result.toVersion ? (
+        <Text color="green">✓ Lincoln is up to date ({result.fromVersion}).</Text>
+      ) : result.success && dryRun ? (
+        <>
+          <Text color="cyan">◌ Dry run: {result.fromVersion} → {result.toVersion} available.</Text>
+          <Text>Re-run without --dry-run to apply the update.</Text>
+        </>
+      ) : result.success ? (
+        <>
+          <Text color="green">✓ Update complete: {result.fromVersion} → {result.toVersion}.</Text>
+          {result.updated.length > 0 && (
+            <Box flexDirection="column" marginTop={1}>
+              <Text bold>Updated files:</Text>
+              {result.updated.slice(0, 10).map((file) => (
+                <Text key={file}>  {file}</Text>
+              ))}
+              {result.updated.length > 10 && <Text dimColor>  ...and {result.updated.length - 10} more.</Text>}
+            </Box>
+          )}
+          {result.preserved.length > 0 && (
+            <Box flexDirection="column" marginTop={1}>
+              <Text bold>Preserved user data:</Text>
+              {result.preserved.map((path) => (
+                <Text key={path}>  {path}</Text>
+              ))}
+            </Box>
+          )}
+        </>
+      ) : (
+        <>
+          <Text color="red">✗ Update failed.</Text>
+          {result.error && <Text>{result.error}</Text>}
+        </>
+      )}
+      <Box marginTop={1}>
+        <Text dimColor>Press Enter to exit.</Text>
+      </Box>
+    </Box>
+  )
+}

package/framework/tools/lincoln-installer/src/components/WelcomeScreen.tsx

@@ -0,0 +1,22 @@
+import { Box, Text, useInput } from 'ink'
+import React from 'react'
+
+export interface WelcomeScreenProps {
+  onStart: () => void
+}
+
+export function WelcomeScreen({ onStart }: WelcomeScreenProps) {
+  useInput((_, key) => {
+    if (key.return) {
+      onStart()
+    }
+  })
+
+  return (
+    <Box flexDirection="column" padding={1}>
+      <Text bold color="cyan">Welcome to Lincoln</Text>
+      <Text>This installer will set up Lincoln in your project.</Text>
+      <Text dimColor>Press Enter to start.</Text>
+    </Box>
+  )
+}