@sushanglewis/lincoln 1.5.0 → 1.5.2

package/framework/tools/lincoln/src/components/RecordingScreen.tsx

@@ -0,0 +1,41 @@
+import { Box, Text } from 'ink'
+import React from 'react'
+
+import { AudioMeter } from './AudioMeter'
+import { formatDuration } from '../utils/formatDuration'
+
+export interface RecordingScreenProps {
+  sessionId: string
+  topic: string
+  designId: string
+  duration: number
+  amplitude: number
+  audioMeterStyle?: 'bar' | 'dot' | 'wave'
+}
+
+export function RecordingScreen({
+  sessionId,
+  topic,
+  designId,
+  duration,
+  amplitude,
+  audioMeterStyle = 'bar',
+}: RecordingScreenProps) {
+  return (
+    <Box flexDirection="column" padding={1}>
+      <Text bold>Lincoln Recorder</Text>
+      <Text dimColor>Session: {sessionId}</Text>
+      {topic ? <Text>Topic: {topic}</Text> : null}
+      {designId ? <Text>Design: {designId}</Text> : null}
+      <Text />
+      <Box>
+        <Text color="red">●</Text>
+        <Text> Recording {formatDuration(duration)}</Text>
+      </Box>
+      <Text />
+      <AudioMeter amplitude={amplitude} style={audioMeterStyle} />
+      <Text />
+      <Text dimColor>Press Enter to stop · Press q to cancel</Text>
+    </Box>
+  )
+}

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

@@ -0,0 +1,53 @@
+import { Box, Text, useInput } from 'ink'
+import React, { useState } from 'react'
+
+export interface SelectMenuItem {
+  key: string
+  label: string
+}
+
+export interface SelectMenuProps {
+  title: string
+  items: SelectMenuItem[]
+  onSelect: (key: string) => void
+  onClose: () => void
+  footer?: string
+}
+
+export function SelectMenu({ title, items, onSelect, onClose, footer }: SelectMenuProps) {
+  const [index, setIndex] = useState(0)
+
+  useInput((_input, key) => {
+    if (key.escape) {
+      onClose()
+      return
+    }
+    if (key.upArrow) {
+      setIndex(i => (i > 0 ? i - 1 : items.length - 1))
+      return
+    }
+    if (key.downArrow) {
+      setIndex(i => (i < items.length - 1 ? i + 1 : 0))
+      return
+    }
+    if (key.return && items.length > 0) {
+      onSelect(items[Math.min(index, items.length - 1)].key)
+    }
+  })
+
+  return (
+    <Box flexDirection="column" paddingX={1}>
+      <Text bold>{title}</Text>
+      {items.length === 0 ? (
+        <Text dimColor>(none)</Text>
+      ) : (
+        items.map((item, i) => (
+          <Text key={item.key} color={i === index ? 'cyan' : undefined}>
+            {i === index ? '›' : ' '} {item.label}
+          </Text>
+        ))
+      )}
+      {footer ? <Text dimColor>{footer}</Text> : null}
+    </Box>
+  )
+}

package/framework/tools/lincoln/src/components/StatusPanel.tsx

@@ -0,0 +1,52 @@
+import { Box, Text } from 'ink'
+import React from 'react'
+
+import { formatDuration } from '../utils/formatDuration'
+
+export interface StatusPanelProps {
+  sessionId: string
+  topic?: string
+  designId?: string
+  branch?: string
+  status: 'idle' | 'recording' | 'stopped' | 'cancelled' | 'error'
+  duration: number
+  amplitude?: number
+}
+
+export function StatusPanel({
+  sessionId,
+  topic,
+  designId,
+  branch,
+  status,
+  duration,
+}: StatusPanelProps) {
+  const statusLabel = {
+    idle: 'Ready',
+    recording: `Recording ${formatDuration(duration)}`,
+    stopped: 'Stopped',
+    cancelled: 'Cancelled',
+    error: 'Error',
+  }[status]
+
+  const statusColor = status === 'recording' ? 'red' : status === 'error' ? 'red' : status === 'cancelled' ? 'yellow' : 'green'
+
+  return (
+    <Box flexDirection="column" paddingX={1} paddingTop={1}>
+      <Box flexDirection="row" justifyContent="space-between" alignItems="center">
+        <Text bold color="white">Lincoln Recorder</Text>
+        <Box flexDirection="row" gap={1}>
+          <Text color={statusColor}>{status === 'recording' ? '●' : '○'}</Text>
+          <Text>{statusLabel}</Text>
+        </Box>
+      </Box>
+
+      <Box flexDirection="column" paddingY={1}>
+        <Text dimColor>Session: {sessionId}</Text>
+        {topic ? <Text dimColor>Topic: {topic}</Text> : null}
+        {designId ? <Text dimColor>Design: {designId}</Text> : null}
+        {branch ? <Text dimColor>Branch: {branch}</Text> : null}
+      </Box>
+    </Box>
+  )
+}

package/framework/tools/lincoln/src/components/StopConfirmation.tsx

@@ -0,0 +1,32 @@
+import { Box, Text, useInput } from 'ink'
+import React from 'react'
+
+export interface StopConfirmationProps {
+  sessionId: string
+  workspaceRoot?: string
+  onConfirm: () => void
+  onCancel?: () => void
+}
+
+export function StopConfirmation({ sessionId, workspaceRoot, onConfirm, onCancel }: StopConfirmationProps) {
+  const command = `claude process-interview ${sessionId}`
+
+  useInput(() => {
+    onConfirm()
+  })
+
+  return (
+    <Box flexDirection="column" padding={1}>
+      <Text bold>Stopped</Text>
+      <Text>Session {sessionId} saved.</Text>
+      {workspaceRoot ? <Text color="gray">Workspace: {workspaceRoot}</Text> : null}
+      <Box paddingY={1} flexDirection="column">
+        <Text>Run this command in your terminal to generate knowledge artifacts:</Text>
+        <Text color="cyan">{command}</Text>
+      </Box>
+      {onCancel
+        ? <Text color="gray">[any key] Copy command and exit · [n] Exit without copying</Text>
+        : <Text color="gray">[any key] Exit</Text>}
+    </Box>
+  )
+}

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

@@ -0,0 +1,35 @@
+import { parseArgs as nodeParseArgs } from 'node:util'
+
+export interface ParsedArgs {
+  topic?: string
+  designId?: string
+  branch?: string
+  sessionId?: string
+  noTui: boolean
+  help: boolean
+}
+
+export function parseArgs(argv: string[]): ParsedArgs {
+  const { values } = nodeParseArgs({
+    args: argv,
+    options: {
+      topic: { type: 'string' },
+      'design-id': { type: 'string' },
+      branch: { type: 'string' },
+      'session-id': { type: 'string' },
+      'no-tui': { type: 'boolean', default: false },
+      help: { type: 'boolean', short: 'h', default: false },
+    },
+    strict: false,
+    allowPositionals: true,
+  })
+
+  return {
+    topic: values.topic as string | undefined,
+    designId: values['design-id'] as string | undefined,
+    branch: values.branch as string | undefined,
+    sessionId: values['session-id'] as string | undefined,
+    noTui: values['no-tui'] as boolean,
+    help: values.help as boolean,
+  }
+}

package/framework/tools/lincoln/src/config/loadConfig.ts

@@ -0,0 +1,81 @@
+import { readFileSync } from 'node:fs'
+import { PathLike } from 'node:fs'
+
+import yaml from 'js-yaml'
+
+export interface LincolnConfig {
+  defaultTopic?: string
+  defaultDesignId?: string
+  defaultBranch?: string
+  autoProcess?: boolean
+  showAudioMeter?: boolean
+  audioMeterStyle?: 'bar' | 'dot' | 'wave'
+}
+
+function parseConfig(content: string, path: PathLike): LincolnConfig {
+  const trimmed = content.trim()
+  if (!trimmed) {
+    return {}
+  }
+
+  const isJson = trimmed.startsWith('{') || trimmed.startsWith('[')
+  const raw = isJson ? JSON.parse(trimmed) : yaml.load(trimmed)
+
+  if (raw === null || typeof raw !== 'object') {
+    return {}
+  }
+
+  const data = raw as Record<string, unknown>
+
+  return {
+    defaultTopic: asString(data.default_topic),
+    defaultDesignId: asString(data.default_design_id),
+    defaultBranch: asString(data.default_branch),
+    autoProcess: asBoolean(data.auto_process),
+    showAudioMeter: asBoolean(data.show_audio_meter),
+    audioMeterStyle: asMeterStyle(data.audio_meter_style),
+  }
+}
+
+function asString(value: unknown): string | undefined {
+  return typeof value === 'string' ? value : undefined
+}
+
+function asBoolean(value: unknown): boolean | undefined {
+  return typeof value === 'boolean' ? value : undefined
+}
+
+function asMeterStyle(value: unknown): LincolnConfig['audioMeterStyle'] {
+  if (value === 'bar' || value === 'dot' || value === 'wave') {
+    return value
+  }
+  return undefined
+}
+
+export function loadConfig(path: PathLike): LincolnConfig {
+  let content: string
+  try {
+    content = readFileSync(path, 'utf-8')
+  } catch (error) {
+    throw new Error(`Config file not found: ${String(path)}`)
+  }
+
+  try {
+    return parseConfig(content, path)
+  } catch (error) {
+    const cause = error instanceof Error ? error.message : String(error)
+    throw new Error(`Failed to parse config ${String(path)}: ${cause}`)
+  }
+}
+
+export function loadConfigOptional(path: PathLike): LincolnConfig {
+  try {
+    return loadConfig(path)
+  } catch (error) {
+    const message = error instanceof Error ? error.message : String(error)
+    if (message.includes('Config file not found')) {
+      return {}
+    }
+    throw error
+  }
+}

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

@@ -0,0 +1,85 @@
+import { existsSync } from 'node:fs'
+import { homedir } from 'node:os'
+import { join } from 'node:path'
+
+import { LincolnConfig, loadConfigOptional } from './loadConfig'
+import { generateSessionId } from '../utils/sessionId'
+
+export interface ParsedArgs {
+  topic?: string
+  designId?: string
+  branch?: string
+  sessionId?: string
+  noTui?: boolean
+  help?: boolean
+}
+
+export interface ResolvedConfig extends Required<Pick<LincolnConfig, 'autoProcess' | 'showAudioMeter' | 'audioMeterStyle'>> {
+  workspaceRoot: string
+  sessionId: string
+  topic: string
+  designId: string
+  branch: string
+  noTui: boolean
+}
+
+interface ResolveOptions {
+  cwd?: string
+  home?: string
+  now?: Date
+}
+
+function pickFirst(...values: Array<string | undefined>): string {
+  for (const value of values) {
+    if (value !== undefined && value !== '') {
+      return value
+    }
+  }
+  return ''
+}
+
+function uniqueSessionId(workspaceRoot: string, now: Date, descriptor?: string): string {
+  const baseSessionId = generateSessionId({ now, descriptor })
+  const recordingPath = join(workspaceRoot, 'recordings', `${baseSessionId}.m4a`)
+  if (!existsSync(recordingPath)) {
+    return baseSessionId
+  }
+
+  for (let counter = 1; counter <= 999; counter += 1) {
+    const candidate = `${baseSessionId}-${String(counter).padStart(3, '0')}`
+    const candidatePath = join(workspaceRoot, 'recordings', `${candidate}.m4a`)
+    if (!existsSync(candidatePath)) {
+      return candidate
+    }
+  }
+
+  return baseSessionId
+}
+
+export function resolveConfig(args: ParsedArgs, options: ResolveOptions = {}): ResolvedConfig {
+  const cwd = options.cwd ?? process.cwd()
+  const home = options.home ?? homedir()
+  const now = options.now ?? new Date()
+
+  const globalConfig = loadConfigOptional(join(home, '.lincolnrc'))
+  const localConfig = loadConfigOptional(join(cwd, '.lincolnrc'))
+
+  const topic = pickFirst(args.topic, localConfig.defaultTopic, globalConfig.defaultTopic)
+  const designId = pickFirst(args.designId, localConfig.defaultDesignId, globalConfig.defaultDesignId)
+  const branch = pickFirst(args.branch, localConfig.defaultBranch, globalConfig.defaultBranch)
+
+  const descriptor = designId || topic || undefined
+  const sessionId = args.sessionId || uniqueSessionId(cwd, now, descriptor)
+
+  return {
+    workspaceRoot: cwd,
+    sessionId,
+    topic,
+    designId,
+    branch,
+    noTui: args.noTui ?? false,
+    autoProcess: localConfig.autoProcess ?? globalConfig.autoProcess ?? false,
+    showAudioMeter: localConfig.showAudioMeter ?? globalConfig.showAudioMeter ?? true,
+    audioMeterStyle: localConfig.audioMeterStyle ?? globalConfig.audioMeterStyle ?? 'bar',
+  }
+}

package/framework/tools/lincoln/src/devices/listDevices.ts

@@ -0,0 +1,11 @@
+import { execFile } from 'node:child_process'
+import { promisify } from 'node:util'
+
+import { parseDevicesOutput, type DeviceList } from './parseDevices'
+
+const execFileAsync = promisify(execFile)
+
+export async function listDevices(lincolnRecordPath = 'lincoln-record'): Promise<DeviceList> {
+  const { stdout } = await execFileAsync(lincolnRecordPath, ['devices'])
+  return parseDevicesOutput(stdout)
+}

package/framework/tools/lincoln/src/devices/parseDevices.ts

@@ -0,0 +1,25 @@
+export interface DeviceList {
+  defaultDevice: string | null
+  devices: string[]
+}
+
+const DEFAULT_PREFIX = 'Default input: '
+
+export function parseDevicesOutput(output: string): DeviceList {
+  let defaultDevice: string | null = null
+  const devices: string[] = []
+
+  for (const rawLine of output.split('\n')) {
+    const line = rawLine.trim()
+    if (!line) continue
+
+    if (line.startsWith(DEFAULT_PREFIX)) {
+      defaultDevice = line.slice(DEFAULT_PREFIX.length).trim() || null
+      continue
+    }
+
+    devices.push(line)
+  }
+
+  return { defaultDevice, devices }
+}

package/framework/tools/lincoln/src/hooks/useKeyHandler.ts

@@ -0,0 +1,63 @@
+import { useInput } from 'ink'
+
+export interface KeyHandlerOptions {
+  enabled?: boolean
+  onRecord?: () => void
+  onStop?: () => void
+  onCancel?: () => void
+  onQuit?: () => void
+  onDevices?: () => void
+  onModel?: () => void
+  onAnyKey?: () => void
+}
+
+export function useKeyHandler({
+  enabled = true,
+  onRecord,
+  onStop,
+  onCancel,
+  onQuit,
+  onDevices,
+  onModel,
+  onAnyKey,
+}: KeyHandlerOptions) {
+  useInput(
+    (input, key) => {
+      if (key.escape || input === 'q' || input === 'Q') {
+        onQuit?.()
+        return
+      }
+
+    if (key.ctrl && input === 'c') {
+      onQuit?.()
+      return
+    }
+
+    switch (input) {
+      case 'r':
+      case 'R':
+        onRecord?.()
+        return
+      case 's':
+      case 'S':
+        onStop?.()
+        return
+      case 'c':
+      case 'C':
+        onCancel?.()
+        return
+      case 'd':
+      case 'D':
+        onDevices?.()
+        return
+      case 'm':
+      case 'M':
+        onModel?.()
+        return
+    }
+
+      onAnyKey?.()
+    },
+    { isActive: enabled },
+  )
+}

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

@@ -0,0 +1,4 @@
+#!/usr/bin/env node
+import { main } from './cli'
+
+main()

package/framework/tools/lincoln/src/models/models.ts

@@ -0,0 +1,34 @@
+import { existsSync } from 'node:fs'
+import { homedir } from 'node:os'
+import { join } from 'node:path'
+
+export const KNOWN_MODELS = [
+  'tiny',
+  'base',
+  'small',
+  'medium',
+  'large-v1',
+  'large-v2',
+  'large-v3',
+  'large-v3-turbo',
+]
+
+export interface ModelStatus {
+  name: string
+  cached: boolean
+}
+
+export function defaultModelCacheDir(): string {
+  return join(homedir(), '.cache', 'lincoln', 'models')
+}
+
+export function modelCachePath(name: string, cacheDir: string): string {
+  return join(cacheDir, 'whisper', `ggml-${name}.bin`)
+}
+
+export function listModelStatuses(cacheDir: string): ModelStatus[] {
+  return KNOWN_MODELS.map(name => ({
+    name,
+    cached: existsSync(modelCachePath(name, cacheDir)),
+  }))
+}

package/framework/tools/lincoln/src/models/runWarmup.ts

@@ -0,0 +1,46 @@
+import { spawn } from 'node:child_process'
+
+import { parseWarmupProgress, type WarmupProgress } from './warmupProgress'
+
+export interface RunWarmupOptions {
+  model: string
+  lincolnRecordPath?: string
+  onProgress?: (progress: WarmupProgress) => void
+}
+
+const READY_LINE = /Model ready at (.+)/
+
+export function runWarmup(options: RunWarmupOptions): Promise<string> {
+  const { model, lincolnRecordPath = 'lincoln-record', onProgress } = options
+
+  return new Promise((resolve, reject) => {
+    const child = spawn(lincolnRecordPath, ['warmup', '--model', model], {
+      stdio: ['ignore', 'pipe', 'pipe'],
+    })
+
+    let readyPath: string | null = null
+
+    child.stdout.on('data', (data: Buffer) => {
+      const match = READY_LINE.exec(data.toString())
+      if (match) {
+        readyPath = match[1].trim()
+      }
+    })
+
+    child.stderr.on('data', (data: Buffer) => {
+      const progress = parseWarmupProgress(data.toString())
+      if (progress) {
+        onProgress?.(progress)
+      }
+    })
+
+    child.on('error', reject)
+    child.on('exit', code => {
+      if (code === 0) {
+        resolve(readyPath ?? model)
+      } else {
+        reject(new Error(`lincoln-record warmup exited with code ${code}`))
+      }
+    })
+  })
+}

package/framework/tools/lincoln/src/models/warmupProgress.ts

@@ -0,0 +1,30 @@
+export interface WarmupProgress {
+  downloaded: number
+  total: number | null
+  percent: number | null
+}
+
+const PROGRESS_WITH_TOTAL = /downloaded (\d+) \/ (\d+) bytes \(([\d.]+)%\)/
+const PROGRESS_WITHOUT_TOTAL = /downloaded (\d+) bytes/
+
+export function parseWarmupProgress(chunk: string): WarmupProgress | null {
+  const withTotal = PROGRESS_WITH_TOTAL.exec(chunk)
+  if (withTotal) {
+    return {
+      downloaded: Number(withTotal[1]),
+      total: Number(withTotal[2]),
+      percent: Number(withTotal[3]),
+    }
+  }
+
+  const withoutTotal = PROGRESS_WITHOUT_TOTAL.exec(chunk)
+  if (withoutTotal) {
+    return {
+      downloaded: Number(withoutTotal[1]),
+      total: null,
+      percent: null,
+    }
+  }
+
+  return null
+}