@sushanglewis/lincoln 1.5.0 → 1.5.1

package/framework/tools/lincoln-installer/src/config/args.ts

@@ -0,0 +1,76 @@
+export interface ParsedArgs {
+  root: string
+  harness: string[]
+  yes: boolean
+  dryRun: boolean
+  noTui: boolean
+  format: 'human' | 'json'
+  help: boolean
+}
+
+function takeValue(argv: string[], i: number, name: string): string {
+  const value = argv[i + 1]
+  if (value === undefined || value.startsWith('--')) {
+    throw new Error(`Missing value for ${name}`)
+  }
+  return value
+}
+
+export function parseArgs(argv: string[]): ParsedArgs {
+  const args: ParsedArgs = {
+    root: '.',
+    harness: [],
+    yes: false,
+    dryRun: false,
+    noTui: false,
+    format: 'human',
+    help: false,
+  }
+
+  for (let i = 0; i < argv.length; i++) {
+    const arg = argv[i]
+    switch (arg) {
+      case '--root': {
+        const value = takeValue(argv, i, '--root')
+        args.root = value
+        i++
+        break
+      }
+      case '--harness': {
+        const value = takeValue(argv, i, '--harness')
+        args.harness.push(value)
+        i++
+        break
+      }
+      case '--yes':
+        args.yes = true
+        break
+      case '--dry-run':
+        args.dryRun = true
+        break
+      case '--no-tui':
+        args.noTui = true
+        break
+      case '--format': {
+        const value = takeValue(argv, i, '--format')
+        if (value !== 'human' && value !== 'json') {
+          throw new Error(`Invalid value for --format: ${value}. Must be 'human' or 'json'.`)
+        }
+        args.format = value
+        i++
+        break
+      }
+      case '-h':
+      case '--help':
+        args.help = true
+        break
+      default:
+        if (arg.startsWith('--')) {
+          throw new Error(`Unknown argument: ${arg}`)
+        }
+        break
+    }
+  }
+
+  return args
+}

package/framework/tools/lincoln-installer/src/config/resolveConfig.ts

@@ -0,0 +1,33 @@
+import { existsSync, statSync } from 'node:fs'
+import { resolve } from 'node:path'
+
+import type { ParsedArgs } from './args'
+
+export interface InstallerConfig {
+  root: string
+  harnesses: string[]
+  yes: boolean
+  dryRun: boolean
+  format: 'human' | 'json'
+}
+
+export function resolveConfig(args: ParsedArgs): InstallerConfig {
+  const root = resolve(args.root)
+  if (!existsSync(root) || !statSync(root).isDirectory()) {
+    throw new Error(`Project root does not exist or is not a directory: ${root}`)
+  }
+  const setupScript = resolve(root, 'scripts', 'lincoln-setup.py')
+  if (!existsSync(setupScript)) {
+    throw new Error(
+      `Lincoln setup script not found at ${setupScript}. ` +
+        `Run lincoln-install inside a Lincoln project checkout.`
+    )
+  }
+  return {
+    root,
+    harnesses: args.harness.length > 0 ? args.harness : [],
+    yes: args.yes,
+    dryRun: args.dryRun,
+    format: args.format,
+  }
+}

package/framework/tools/lincoln-installer/src/config/updateArgs.ts

@@ -0,0 +1,67 @@
+import { validateRepoSlug } from '../utils/updateRelease'
+
+export interface UpdateParsedArgs {
+  root: string
+  repo: string
+  dryRun: boolean
+  noTui: boolean
+  format: 'human' | 'json'
+  help: boolean
+}
+
+function takeValue(argv: string[], i: number, name: string): string {
+  const value = argv[i + 1]
+  if (value === undefined || value.startsWith('--')) {
+    throw new Error(`Missing value for ${name}`)
+  }
+  return value
+}
+
+export function parseUpdateArgs(argv: string[]): UpdateParsedArgs {
+  const args: UpdateParsedArgs = {
+    root: '.',
+    repo: 'sushanglewis/Lincoln',
+    dryRun: false,
+    noTui: false,
+    format: 'human',
+    help: false,
+  }
+
+  for (let i = 0; i < argv.length; i++) {
+    const arg = argv[i]
+    switch (arg) {
+      case '--root':
+        args.root = takeValue(argv, i, '--root')
+        i++
+        break
+      case '--repo':
+        args.repo = takeValue(argv, i, '--repo')
+        validateRepoSlug(args.repo)
+        i++
+        break
+      case '--dry-run':
+        args.dryRun = true
+        break
+      case '--no-tui':
+        args.noTui = true
+        break
+      case '--format': {
+        const value = takeValue(argv, i, '--format')
+        if (value !== 'human' && value !== 'json') {
+          throw new Error(`Invalid value for --format: ${value}`)
+        }
+        args.format = value
+        i++
+        break
+      }
+      case '--help':
+      case '-h':
+        args.help = true
+        break
+      default:
+        throw new Error(`Unknown argument: ${arg}`)
+    }
+  }
+
+  return args
+}

package/framework/tools/lincoln-installer/src/hooks/useSetup.ts

@@ -0,0 +1,149 @@
+import { existsSync } from 'node:fs'
+import { resolve } from 'node:path'
+import { useCallback, useState } from 'react'
+
+import { runSetup, parseJsonOutput, type RunSetupResult } from '../utils/runSetup'
+
+export type SetupPhase =
+  | 'welcome'
+  | 'harness'
+  | 'options'
+  | 'summary'
+  | 'running'
+  | 'result'
+
+export interface SetupOptions {
+  root: string
+  harnesses: string[]
+  yes: boolean
+  dryRun: boolean
+}
+
+export interface StepResult {
+  step: string
+  success: boolean
+  output?: unknown
+  error?: string
+}
+
+export interface UseSetupReturn {
+  isRunning: boolean
+  results: StepResult[]
+  currentStep: string
+  error?: string
+  startSetup: (options: SetupOptions) => void
+}
+
+function getPythonCommand(): string {
+  if (process.platform === 'win32') {
+    return 'python'
+  }
+  return 'python3'
+}
+
+export function useSetup(): UseSetupReturn {
+  const [isRunning, setIsRunning] = useState(false)
+  const [results, setResults] = useState<StepResult[]>([])
+  const [currentStep, setCurrentStep] = useState<string>('')
+  const [error, setError] = useState<string | undefined>(undefined)
+
+  const runStep = useCallback(
+    async (label: string, command: string, args: string[], root: string): Promise<StepResult> => {
+      setCurrentStep(label)
+      const result: RunSetupResult = await runSetup({ root, command, args })
+      const output = parseJsonOutput(result.stdout)
+      const stepResult: StepResult = {
+        step: label,
+        success: result.success,
+        output,
+        error: result.error || (result.success ? undefined : result.stderr || 'unknown error'),
+      }
+      setResults((prev) => [...prev, stepResult])
+      return stepResult
+    },
+    []
+  )
+
+  const startSetup = useCallback(
+    (options: SetupOptions) => {
+      setIsRunning(true)
+      setResults([])
+      setError(undefined)
+
+      async function runAll(): Promise<void> {
+        const setupScript = resolve(options.root, 'scripts', 'lincoln-setup.py')
+        if (!existsSync(setupScript)) {
+          throw new Error(
+            `Lincoln setup script not found at ${setupScript}. ` +
+              `Run lincoln-install inside a Lincoln project checkout.`
+          )
+        }
+
+        const format = '--format=json'
+        const rootArg = `--root=${options.root}`
+        const yesArg = options.yes ? '--yes' : undefined
+        const dryRunArg = options.dryRun ? '--dry-run' : undefined
+        const commonArgs = [rootArg, format, yesArg, dryRunArg].filter(
+          (arg): arg is string => arg !== undefined
+        )
+
+        const python = getPythonCommand()
+
+        const check = await runStep('check', python, [setupScript, 'check', ...commonArgs], options.root)
+        if (!check.success) {
+          return
+        }
+
+        const skills = await runStep('install-skills', python, [setupScript, 'install-skills', ...commonArgs], options.root)
+        if (!skills.success) {
+          return
+        }
+
+        const clis = await runStep('install-clis', python, [setupScript, 'install-clis', ...commonArgs], options.root)
+        if (!clis.success) {
+          return
+        }
+
+        const config = await runStep('init-repo-config', python, [setupScript, 'init-repo-config', ...commonArgs], options.root)
+        if (!config.success) {
+          return
+        }
+
+        const project = await runStep('init-project', python, [setupScript, 'init-project', ...commonArgs], options.root)
+        if (!project.success) {
+          return
+        }
+
+        if (options.harnesses.length > 0) {
+          const harnessArgs = options.harnesses.flatMap((h) => ['--harness', h])
+          const harness = await runStep(
+            'generate-harness',
+            python,
+            [setupScript, 'generate-harness', ...commonArgs, ...harnessArgs],
+            options.root
+          )
+          if (!harness.success) {
+            return
+          }
+        }
+      }
+
+      runAll()
+        .catch((err) => {
+          setError(err instanceof Error ? err.message : String(err))
+        })
+        .finally(() => {
+          setIsRunning(false)
+        })
+    },
+    [runStep]
+  )
+
+  return {
+    isRunning,
+    results,
+    currentStep,
+    error,
+    startSetup,
+  }
+}

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

@@ -0,0 +1,11 @@
+#!/usr/bin/env node
+import { main } from './cli'
+
+console.log(
+  '⚠️  lincoln-install is deprecated. Run: npm install -g @sushanglewis/lincoln && lincoln install'
+)
+
+main().catch((err) => {
+  console.error(err instanceof Error ? err.message : String(err))
+  process.exit(1)
+})

package/framework/tools/lincoln-installer/src/types.ts

@@ -0,0 +1,19 @@
+export interface HarnessInfo {
+  id: string
+  name: string
+  description: string
+  installed: boolean
+  projectDir?: string
+  globalDir?: string
+}
+
+export interface SetupStep {
+  command: string
+  label: string
+}
+
+export interface SetupResult {
+  success: boolean
+  step?: string
+  error?: string
+}

package/framework/tools/lincoln-installer/src/update-main.tsx

@@ -0,0 +1,11 @@
+#!/usr/bin/env node
+import { updateMain } from './update'
+
+console.log(
+  '⚠️  lincoln-update is deprecated. Run: npm install -g @sushanglewis/lincoln && lincoln install'
+)
+
+updateMain().catch((err) => {
+  console.error(err instanceof Error ? err.message : String(err))
+  process.exit(1)
+})

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

@@ -0,0 +1,90 @@
+#!/usr/bin/env node
+import { Box, Text } from 'ink'
+import React from 'react'
+
+import { parseUpdateArgs } from './config/updateArgs'
+import { UpdateApp } from './components/UpdateApp'
+import { updateRelease, type UpdateResult } from './utils/updateRelease'
+
+function printHumanResult(result: UpdateResult): void {
+  if (!result.success) {
+    console.log(`Update failed: ${result.error ?? 'unknown error'}`)
+    return
+  }
+  if (result.fromVersion === result.toVersion) {
+    console.log(`Lincoln is up to date (${result.fromVersion}).`)
+    return
+  }
+  console.log(`Update available: ${result.fromVersion} → ${result.toVersion}`)
+  if (result.updated.length > 0) {
+    console.log(`Updated files (${result.updated.length}):`)
+    for (const file of result.updated.slice(0, 10)) {
+      console.log(`  ${file}`)
+    }
+    if (result.updated.length > 10) {
+      console.log(`  ...and ${result.updated.length - 10} more`)
+    }
+  }
+  if (result.preserved.length > 0) {
+    console.log('Preserved user data:')
+    for (const path of result.preserved) {
+      console.log(`  ${path}`)
+    }
+  }
+  if (result.backupDir) {
+    console.log(`Backup directory: ${result.backupDir}`)
+  }
+}
+
+export function UpdateAppRoot({ args }: { args: ReturnType<typeof parseUpdateArgs> }) {
+  if (args.help) {
+    return (
+      <Box flexDirection="column" padding={1}>
+        <Text bold>lincoln-update</Text>
+        <Text>Update Lincoln to the latest release.</Text>
+        <Text />
+        <Text bold>Usage:</Text>
+        <Text>  npx lincoln-update [options]</Text>
+        <Text />
+        <Text bold>Options:</Text>
+        <Text>  --root        Project root directory (default: current dir)</Text>
+        <Text>  --repo        GitHub repository slug (default: sushanglewis/Lincoln)</Text>
+        <Text>  --dry-run     Show what would be updated without applying changes</Text>
+        <Text>  --no-tui      Print result as JSON and exit</Text>
+        <Text>  --format      Output format: human|json (default: human)</Text>
+        <Text>  --help, -h    Show this help message</Text>
+      </Box>
+    )
+  }
+
+  return <UpdateApp root={args.root} repo={args.repo} dryRun={args.dryRun} />
+}
+
+export async function updateMain(argv: string[] = process.argv.slice(2)): Promise<void> {
+  try {
+    const args = parseUpdateArgs(argv)
+
+    if (args.help) {
+      const { render } = await import('ink')
+      render(<UpdateAppRoot args={args} />)
+      return
+    }
+
+    if (args.noTui) {
+      const result = await updateRelease({ root: args.root, repo: args.repo, dryRun: args.dryRun })
+      if (args.format === 'human') {
+        printHumanResult(result)
+      } else {
+        console.log(JSON.stringify(result, null, 2))
+      }
+      return
+    }
+
+    const { render } = await import('ink')
+    render(<UpdateAppRoot args={args} />)
+  } catch (err) {
+    const message = err instanceof Error ? err.message : String(err)
+    console.error(`Error: ${message}`)
+    process.exitCode = 1
+  }
+}

package/framework/tools/lincoln-installer/src/utils/detectHarness.ts

@@ -0,0 +1,51 @@
+import { existsSync } from 'node:fs'
+import { homedir } from 'node:os'
+import { join } from 'node:path'
+
+import type { HarnessInfo } from '../types'
+
+const HARNESS_DEFINITIONS: Omit<HarnessInfo, 'installed'>[] = [
+  {
+    id: 'claude-code',
+    name: 'Claude Code',
+    description: 'Anthropic Claude Code agent',
+    projectDir: '.claude',
+  },
+  {
+    id: 'cursor',
+    name: 'Cursor',
+    description: 'Cursor editor rules',
+    projectDir: '.cursor',
+  },
+  {
+    id: 'codex',
+    name: 'Codex',
+    description: 'OpenAI Codex CLI',
+    projectDir: '.codex',
+  },
+  {
+    id: 'opencode',
+    name: 'OpenCode',
+    description: 'OpenCode agent',
+    projectDir: '.opencode',
+  },
+]
+
+function globalDirFor(id: string, homeDir: string): string | undefined {
+  if (id === 'cursor') return undefined
+  return join(homeDir, '.' + id.replace('claude-code', 'claude'))
+}
+
+export function detectHarnesses(root: string, homeDir: string = homedir()): HarnessInfo[] {
+  return HARNESS_DEFINITIONS.map((harness) => {
+    const projectInstalled = harness.projectDir
+      ? existsSync(join(root, harness.projectDir))
+      : false
+    const global = globalDirFor(harness.id, homeDir)
+    const globalInstalled = global ? existsSync(global) : false
+    return {
+      ...harness,
+      installed: projectInstalled || globalInstalled,
+    }
+  })
+}

package/framework/tools/lincoln-installer/src/utils/runSetup.ts

@@ -0,0 +1,62 @@
+import { spawn } from 'node:child_process'
+
+export interface RunSetupOptions {
+  root: string
+  command: string
+  args: string[]
+}
+
+export interface RunSetupResult {
+  success: boolean
+  code: number | null
+  stdout: string
+  stderr: string
+  error?: string
+}
+
+export function runSetup(options: RunSetupOptions): Promise<RunSetupResult> {
+  return new Promise((resolve) => {
+    const { root, command, args } = options
+    const proc = spawn(command, args, {
+      cwd: root,
+      stdio: ['ignore', 'pipe', 'pipe'],
+    })
+
+    let stdout = ''
+    let stderr = ''
+    let settled = false
+
+    function finish(result: RunSetupResult): void {
+      if (settled) return
+      settled = true
+      resolve(result)
+    }
+
+    proc.stdout.on('data', (data: Buffer) => {
+      stdout += data.toString('utf-8')
+    })
+
+    proc.stderr.on('data', (data: Buffer) => {
+      stderr += data.toString('utf-8')
+    })
+
+    proc.on('error', (error) => {
+      finish({ success: false, code: null, stdout, stderr, error: error.message })
+    })
+
+    proc.on('close', (code) => {
+      finish({ success: code === 0, code, stdout, stderr })
+    })
+  })
+}
+
+export function parseJsonOutput(stdout: string): unknown {
+  const lines = stdout.trim().split('\n')
+  const lastLine = lines[lines.length - 1]
+  if (!lastLine) return undefined
+  try {
+    return JSON.parse(lastLine)
+  } catch {
+    return undefined
+  }
+}