@sushanglewis/lincoln 1.5.0

package/dist/main.js

@@ -0,0 +1,1009 @@
+#!/usr/bin/env node
+
+// src/cli.tsx
+import { Box as Box8, Text as Text7 } from "ink";
+
+// src/config/args.ts
+import { parseArgs as nodeParseArgs } from "util";
+function parseArgs(argv) {
+  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,
+    designId: values["design-id"],
+    branch: values.branch,
+    sessionId: values["session-id"],
+    noTui: values["no-tui"],
+    help: values.help
+  };
+}
+
+// src/config/resolveConfig.ts
+import { existsSync } from "fs";
+import { homedir } from "os";
+import { join } from "path";
+
+// src/config/loadConfig.ts
+import { readFileSync } from "fs";
+import yaml from "js-yaml";
+function parseConfig(content, path) {
+  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;
+  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) {
+  return typeof value === "string" ? value : void 0;
+}
+function asBoolean(value) {
+  return typeof value === "boolean" ? value : void 0;
+}
+function asMeterStyle(value) {
+  if (value === "bar" || value === "dot" || value === "wave") {
+    return value;
+  }
+  return void 0;
+}
+function loadConfig(path) {
+  let content;
+  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}`);
+  }
+}
+function loadConfigOptional(path) {
+  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;
+  }
+}
+
+// src/utils/sessionId.ts
+function generateSessionId(options = {}) {
+  const now = options.now ?? /* @__PURE__ */ new Date();
+  const date = now.toISOString().slice(0, 10);
+  const slug = normalizeDescriptor(options.descriptor);
+  return `${date}-${slug}`;
+}
+function normalizeDescriptor(descriptor) {
+  if (!descriptor) {
+    return "recording";
+  }
+  const normalized = descriptor.trim().toLowerCase().replace(/[^a-z0-9一-龥]+/g, "-").replace(/^-+|-+$/g, "");
+  return normalized.slice(0, 80) || "recording";
+}
+
+// src/config/resolveConfig.ts
+function pickFirst(...values) {
+  for (const value of values) {
+    if (value !== void 0 && value !== "") {
+      return value;
+    }
+  }
+  return "";
+}
+function uniqueSessionId(workspaceRoot, now, descriptor) {
+  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;
+}
+function resolveConfig(args, options = {}) {
+  const cwd = options.cwd ?? process.cwd();
+  const home = options.home ?? homedir();
+  const now = options.now ?? /* @__PURE__ */ 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 || void 0;
+  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"
+  };
+}
+
+// src/components/RecordingApp.tsx
+import { Box as Box7, useApp } from "ink";
+import { useCallback as useCallback2, useEffect as useEffect4, useMemo, useState as useState5 } from "react";
+
+// src/components/StatusPanel.tsx
+import { Box, Text } from "ink";
+
+// src/utils/formatDuration.ts
+function formatDuration(totalSeconds) {
+  const safeSeconds = Math.max(0, Math.floor(totalSeconds));
+  const minutes = Math.floor(safeSeconds / 60);
+  const seconds = safeSeconds % 60;
+  return `${String(minutes).padStart(2, "0")}:${String(seconds).padStart(2, "0")}`;
+}
+
+// src/components/StatusPanel.tsx
+import { jsx, jsxs } from "react/jsx-runtime";
+function StatusPanel({
+  sessionId,
+  topic,
+  designId,
+  branch,
+  status,
+  duration
+}) {
+  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 /* @__PURE__ */ jsxs(Box, { flexDirection: "column", paddingX: 1, paddingTop: 1, children: [
+    /* @__PURE__ */ jsxs(Box, { flexDirection: "row", justifyContent: "space-between", alignItems: "center", children: [
+      /* @__PURE__ */ jsx(Text, { bold: true, color: "white", children: "Lincoln Recorder" }),
+      /* @__PURE__ */ jsxs(Box, { flexDirection: "row", gap: 1, children: [
+        /* @__PURE__ */ jsx(Text, { color: statusColor, children: status === "recording" ? "\u25CF" : "\u25CB" }),
+        /* @__PURE__ */ jsx(Text, { children: statusLabel })
+      ] })
+    ] }),
+    /* @__PURE__ */ jsxs(Box, { flexDirection: "column", paddingY: 1, children: [
+      /* @__PURE__ */ jsxs(Text, { dimColor: true, children: [
+        "Session: ",
+        sessionId
+      ] }),
+      topic ? /* @__PURE__ */ jsxs(Text, { dimColor: true, children: [
+        "Topic: ",
+        topic
+      ] }) : null,
+      designId ? /* @__PURE__ */ jsxs(Text, { dimColor: true, children: [
+        "Design: ",
+        designId
+      ] }) : null,
+      branch ? /* @__PURE__ */ jsxs(Text, { dimColor: true, children: [
+        "Branch: ",
+        branch
+      ] }) : null
+    ] })
+  ] });
+}
+
+// src/components/LogView.tsx
+import { Box as Box2, Text as Text2 } from "ink";
+import { jsx as jsx2, jsxs as jsxs2 } from "react/jsx-runtime";
+var TYPE_COLORS = {
+  info: void 0,
+  success: "green",
+  error: "red",
+  command: "cyan"
+};
+function LogView({ logs }) {
+  const visible = logs.slice(-8);
+  return /* @__PURE__ */ jsxs2(Box2, { flexDirection: "column", paddingX: 1, flexGrow: 1, children: [
+    /* @__PURE__ */ jsx2(Text2, { underline: true, dimColor: true, children: "Log" }),
+    visible.length === 0 ? /* @__PURE__ */ jsx2(Text2, { dimColor: true, children: "No events yet." }) : visible.map((log) => /* @__PURE__ */ jsx2(Text2, { color: TYPE_COLORS[log.type ?? "info"], children: log.message }, log.id))
+  ] });
+}
+
+// src/components/HintBar.tsx
+import { Box as Box3, Text as Text3 } from "ink";
+import { jsx as jsx3 } from "react/jsx-runtime";
+var HINTS = {
+  idle: "[r] record  [d] devices  [m] model  [q] quit",
+  recording: "[s] stop  [c] cancel",
+  stopped: "[any key] exit",
+  cancelled: "[q] exit",
+  error: "[q] exit",
+  menu: "[\u2191\u2193] select  [enter] confirm  [esc] back"
+};
+function HintBar({ mode }) {
+  return /* @__PURE__ */ jsx3(Box3, { paddingX: 1, paddingY: 1, children: /* @__PURE__ */ jsx3(Text3, { dimColor: true, children: HINTS[mode] }) });
+}
+
+// src/components/DevicesMenu.tsx
+import { Box as Box5, Text as Text5, useInput as useInput2 } from "ink";
+import { useEffect, useState as useState2 } from "react";
+
+// src/components/SelectMenu.tsx
+import { Box as Box4, Text as Text4, useInput } from "ink";
+import { useState } from "react";
+import { jsx as jsx4, jsxs as jsxs3 } from "react/jsx-runtime";
+function SelectMenu({ title, items, onSelect, onClose, footer }) {
+  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 /* @__PURE__ */ jsxs3(Box4, { flexDirection: "column", paddingX: 1, children: [
+    /* @__PURE__ */ jsx4(Text4, { bold: true, children: title }),
+    items.length === 0 ? /* @__PURE__ */ jsx4(Text4, { dimColor: true, children: "(none)" }) : items.map((item, i) => /* @__PURE__ */ jsxs3(Text4, { color: i === index ? "cyan" : void 0, children: [
+      i === index ? "\u203A" : " ",
+      " ",
+      item.label
+    ] }, item.key)),
+    footer ? /* @__PURE__ */ jsx4(Text4, { dimColor: true, children: footer }) : null
+  ] });
+}
+
+// src/components/DevicesMenu.tsx
+import { jsx as jsx5, jsxs as jsxs4 } from "react/jsx-runtime";
+function DevicesMenu({ listDevicesFn, onSelect, onClose }) {
+  const [loadState, setLoadState] = useState2({ status: "loading" });
+  useEffect(() => {
+    let cancelled = false;
+    listDevicesFn().then((list2) => {
+      if (!cancelled) setLoadState({ status: "loaded", list: list2 });
+    }).catch((error) => {
+      if (!cancelled) {
+        setLoadState({
+          status: "error",
+          message: error instanceof Error ? error.message : String(error)
+        });
+      }
+    });
+    return () => {
+      cancelled = true;
+    };
+  }, [listDevicesFn]);
+  useInput2(
+    (_input, key) => {
+      if (key.escape) onClose();
+    },
+    { isActive: loadState.status !== "loaded" }
+  );
+  if (loadState.status === "loading") {
+    return /* @__PURE__ */ jsx5(Box5, { paddingX: 1, children: /* @__PURE__ */ jsx5(Text5, { dimColor: true, children: "Loading devices\u2026" }) });
+  }
+  if (loadState.status === "error") {
+    return /* @__PURE__ */ jsxs4(Box5, { flexDirection: "column", paddingX: 1, children: [
+      /* @__PURE__ */ jsxs4(Text5, { color: "red", children: [
+        "Failed to list devices: ",
+        loadState.message
+      ] }),
+      /* @__PURE__ */ jsx5(Text5, { dimColor: true, children: "[esc] back" })
+    ] });
+  }
+  const { list } = loadState;
+  const items = list.devices.map((name) => ({
+    key: name,
+    label: name === list.defaultDevice ? `${name} (default)` : name
+  }));
+  return /* @__PURE__ */ jsx5(
+    SelectMenu,
+    {
+      title: "Devices",
+      items,
+      onSelect,
+      onClose,
+      footer: "[\u2191\u2193] select  [enter] confirm  [esc] back"
+    }
+  );
+}
+
+// src/components/ModelMenu.tsx
+import { Box as Box6, Text as Text6, useInput as useInput3 } from "ink";
+import { useEffect as useEffect2, useState as useState3 } from "react";
+import { jsx as jsx6, jsxs as jsxs5 } from "react/jsx-runtime";
+function ModelMenu({ listModelStatusesFn, runWarmupFn, onSelect, onClose }) {
+  const [menuState, setMenuState] = useState3({ status: "loading" });
+  useEffect2(() => {
+    let cancelled = false;
+    listModelStatusesFn().then((models) => {
+      if (!cancelled) setMenuState({ status: "loaded", models });
+    }).catch((error) => {
+      if (!cancelled) {
+        setMenuState({
+          status: "error",
+          message: error instanceof Error ? error.message : String(error)
+        });
+      }
+    });
+    return () => {
+      cancelled = true;
+    };
+  }, [listModelStatusesFn]);
+  useInput3(
+    (_input, key) => {
+      if (key.escape) onClose();
+    },
+    { isActive: menuState.status === "error" }
+  );
+  const handleSelect = (name) => {
+    if (menuState.status !== "loaded") return;
+    const target = menuState.models.find((m) => m.name === name);
+    if (!target) return;
+    if (target.cached) {
+      onSelect(name);
+      return;
+    }
+    setMenuState({ status: "downloading", model: name, percent: null, downloaded: 0 });
+    runWarmupFn(name, (progress) => {
+      setMenuState({
+        status: "downloading",
+        model: name,
+        percent: progress.percent,
+        downloaded: progress.downloaded
+      });
+    }).then(() => onSelect(name)).catch((error) => {
+      setMenuState({
+        status: "error",
+        message: error instanceof Error ? error.message : String(error)
+      });
+    });
+  };
+  if (menuState.status === "loading") {
+    return /* @__PURE__ */ jsx6(Box6, { paddingX: 1, children: /* @__PURE__ */ jsx6(Text6, { dimColor: true, children: "Loading models\u2026" }) });
+  }
+  if (menuState.status === "error") {
+    return /* @__PURE__ */ jsxs5(Box6, { flexDirection: "column", paddingX: 1, children: [
+      /* @__PURE__ */ jsx6(Text6, { color: "red", children: menuState.message }),
+      /* @__PURE__ */ jsx6(Text6, { dimColor: true, children: "[esc] back" })
+    ] });
+  }
+  if (menuState.status === "downloading") {
+    const progressText = menuState.percent !== null ? `${menuState.percent.toFixed(1)}%` : `${menuState.downloaded} bytes`;
+    return /* @__PURE__ */ jsxs5(Box6, { flexDirection: "column", paddingX: 1, children: [
+      /* @__PURE__ */ jsxs5(Text6, { children: [
+        "Downloading model '",
+        menuState.model,
+        "'\u2026 ",
+        progressText
+      ] }),
+      /* @__PURE__ */ jsx6(Text6, { dimColor: true, children: "please wait" })
+    ] });
+  }
+  const items = menuState.models.map((m) => ({
+    key: m.name,
+    label: m.cached ? `\u2713 ${m.name}` : `\xB7 ${m.name} (not downloaded)`
+  }));
+  return /* @__PURE__ */ jsx6(
+    SelectMenu,
+    {
+      title: "Model",
+      items,
+      onSelect: handleSelect,
+      onClose,
+      footer: "[\u2191\u2193] select  [enter] confirm  [esc] back"
+    }
+  );
+}
+
+// src/hooks/useKeyHandler.ts
+import { useInput as useInput4 } from "ink";
+function useKeyHandler({
+  enabled = true,
+  onRecord,
+  onStop,
+  onCancel,
+  onQuit,
+  onDevices,
+  onModel,
+  onAnyKey
+}) {
+  useInput4(
+    (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 }
+  );
+}
+
+// src/recording/useRecorder.ts
+import { useCallback, useEffect as useEffect3, useRef, useState as useState4 } from "react";
+
+// src/recording/spawnRecorder.ts
+import { spawn } from "child_process";
+import { EventEmitter } from "events";
+var RecorderProcessImpl = class extends EventEmitter {
+  child;
+  stopped = false;
+  exitPromise;
+  resolveExit = () => {
+  };
+  exitSettled = false;
+  constructor(child) {
+    super();
+    this.child = child;
+    this.exitPromise = new Promise((resolve) => {
+      this.resolveExit = resolve;
+    });
+    this.child.on("error", (error) => {
+      this.emit("error", error);
+      this.settleExit();
+    });
+    this.child.on("exit", (code, signal) => {
+      this.emit("exit", code, signal);
+      this.settleExit();
+    });
+    this.child.stdout.on("data", (data) => {
+      process.stdout.write(data);
+    });
+    this.child.stderr.on("data", (data) => {
+      process.stderr.write(data);
+    });
+    process.nextTick(() => this.emit("ready"));
+  }
+  settleExit() {
+    if (!this.exitSettled) {
+      this.exitSettled = true;
+      this.resolveExit();
+    }
+  }
+  stop() {
+    return this._terminate("SIGINT");
+  }
+  cancel() {
+    return this._terminate("SIGKILL");
+  }
+  _terminate(signal) {
+    if (this.stopped) {
+      return this.exitPromise;
+    }
+    this.stopped = true;
+    if (this.child.killed) {
+      return this.exitPromise;
+    }
+    this.child.kill(signal);
+    const timeout = setTimeout(() => {
+      if (!this.child.killed) {
+        this.child.kill("SIGKILL");
+      }
+    }, 5e3);
+    this.exitPromise.finally(() => clearTimeout(timeout));
+    return this.exitPromise;
+  }
+};
+function spawnRecorder(options) {
+  const {
+    workspaceRoot,
+    sessionId,
+    lincolnRecordPath = "lincoln-record",
+    mic,
+    model
+  } = options;
+  const args = [
+    "record",
+    "--session-id",
+    sessionId,
+    "--output",
+    workspaceRoot
+  ];
+  if (mic) {
+    args.push("--mic", mic);
+  }
+  if (model) {
+    args.push("--model", model);
+  }
+  const child = spawn(lincolnRecordPath, args, {
+    cwd: workspaceRoot,
+    stdio: ["pipe", "pipe", "pipe"]
+  });
+  return new RecorderProcessImpl(child);
+}
+
+// src/recording/useRecorder.ts
+function mockAmplitude(duration) {
+  return 0.5 + 0.4 * Math.sin(duration * 0.8);
+}
+function useRecorder(options) {
+  const {
+    startOnMount = false,
+    workspaceRoot,
+    sessionId,
+    lincolnRecordPath,
+    mic,
+    model
+  } = options;
+  const [state, setState] = useState4({
+    status: "idle",
+    duration: 0,
+    amplitude: 0,
+    errorMessage: null
+  });
+  const recorderRef = useRef(null);
+  const intervalRef = useRef(null);
+  const durationRef = useRef(0);
+  const terminatingRef = useRef(false);
+  const clearRecordingInterval = useCallback(() => {
+    if (intervalRef.current) {
+      clearInterval(intervalRef.current);
+      intervalRef.current = null;
+    }
+  }, []);
+  const start = useCallback(() => {
+    if (recorderRef.current) {
+      return;
+    }
+    terminatingRef.current = false;
+    setState({ status: "recording", duration: 0, amplitude: 0.3, errorMessage: null });
+    durationRef.current = 0;
+    try {
+      const recorder = spawnRecorder({
+        workspaceRoot,
+        sessionId,
+        lincolnRecordPath,
+        mic,
+        model
+      });
+      recorderRef.current = recorder;
+      recorder.on("ready", () => {
+      });
+      recorder.on("error", (error) => {
+        setState((s) => ({ ...s, status: "error", errorMessage: error.message }));
+        clearRecordingInterval();
+      });
+      recorder.on("exit", (code, signal) => {
+        recorderRef.current = null;
+        clearRecordingInterval();
+        if (terminatingRef.current) {
+          return;
+        }
+        const reason = code !== null && code !== void 0 ? `lincoln-record exited unexpectedly with code ${code}` : `lincoln-record exited unexpectedly with signal ${signal}`;
+        setState((s) => ({ ...s, status: "error", errorMessage: reason }));
+      });
+      intervalRef.current = setInterval(() => {
+        durationRef.current += 1;
+        setState((s) => ({
+          ...s,
+          duration: durationRef.current,
+          amplitude: mockAmplitude(durationRef.current)
+        }));
+      }, 1e3);
+    } catch (error) {
+      const message = error instanceof Error ? error.message : String(error);
+      setState((s) => ({ ...s, status: "error", errorMessage: message }));
+    }
+  }, [workspaceRoot, sessionId, lincolnRecordPath, mic, model, clearRecordingInterval]);
+  const stop = useCallback(async () => {
+    const recorder = recorderRef.current;
+    if (!recorder) return;
+    terminatingRef.current = true;
+    clearRecordingInterval();
+    setState((s) => ({ ...s, status: "stopped" }));
+    await recorder.stop();
+  }, [clearRecordingInterval]);
+  const cancel = useCallback(async () => {
+    const recorder = recorderRef.current;
+    if (!recorder) return;
+    terminatingRef.current = true;
+    clearRecordingInterval();
+    setState((s) => ({ ...s, status: "cancelled" }));
+    await recorder.cancel();
+  }, [clearRecordingInterval]);
+  useEffect3(() => {
+    if (startOnMount) {
+      start();
+    }
+    return () => {
+      clearRecordingInterval();
+      if (recorderRef.current) {
+        recorderRef.current.cancel().catch(() => {
+        });
+        recorderRef.current = null;
+      }
+    };
+  }, [startOnMount, start, clearRecordingInterval]);
+  return { state, start, stop, cancel };
+}
+
+// src/devices/listDevices.ts
+import { execFile } from "child_process";
+import { promisify } from "util";
+
+// src/devices/parseDevices.ts
+var DEFAULT_PREFIX = "Default input: ";
+function parseDevicesOutput(output) {
+  let defaultDevice = null;
+  const devices = [];
+  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 };
+}
+
+// src/devices/listDevices.ts
+var execFileAsync = promisify(execFile);
+async function listDevices(lincolnRecordPath = "lincoln-record") {
+  const { stdout } = await execFileAsync(lincolnRecordPath, ["devices"]);
+  return parseDevicesOutput(stdout);
+}
+
+// src/models/models.ts
+import { existsSync as existsSync2 } from "fs";
+import { homedir as homedir2 } from "os";
+import { join as join2 } from "path";
+var KNOWN_MODELS = [
+  "tiny",
+  "base",
+  "small",
+  "medium",
+  "large-v1",
+  "large-v2",
+  "large-v3",
+  "large-v3-turbo"
+];
+function defaultModelCacheDir() {
+  return join2(homedir2(), ".cache", "lincoln", "models");
+}
+function modelCachePath(name, cacheDir) {
+  return join2(cacheDir, "whisper", `ggml-${name}.bin`);
+}
+function listModelStatuses(cacheDir) {
+  return KNOWN_MODELS.map((name) => ({
+    name,
+    cached: existsSync2(modelCachePath(name, cacheDir))
+  }));
+}
+
+// src/models/runWarmup.ts
+import { spawn as spawn2 } from "child_process";
+
+// src/models/warmupProgress.ts
+var PROGRESS_WITH_TOTAL = /downloaded (\d+) \/ (\d+) bytes \(([\d.]+)%\)/;
+var PROGRESS_WITHOUT_TOTAL = /downloaded (\d+) bytes/;
+function parseWarmupProgress(chunk) {
+  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;
+}
+
+// src/models/runWarmup.ts
+var READY_LINE = /Model ready at (.+)/;
+function runWarmup(options) {
+  const { model, lincolnRecordPath = "lincoln-record", onProgress } = options;
+  return new Promise((resolve, reject) => {
+    const child = spawn2(lincolnRecordPath, ["warmup", "--model", model], {
+      stdio: ["ignore", "pipe", "pipe"]
+    });
+    let readyPath = null;
+    child.stdout.on("data", (data) => {
+      const match = READY_LINE.exec(data.toString());
+      if (match) {
+        readyPath = match[1].trim();
+      }
+    });
+    child.stderr.on("data", (data) => {
+      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}`));
+      }
+    });
+  });
+}
+
+// src/components/RecordingApp.tsx
+import { jsx as jsx7, jsxs as jsxs6 } from "react/jsx-runtime";
+function createLogId() {
+  return `${Date.now()}-${Math.random().toString(36).slice(2, 8)}`;
+}
+function RecordingApp({
+  workspaceRoot,
+  sessionId,
+  topic,
+  designId,
+  branch,
+  audioMeterStyle = "bar",
+  lincolnRecordPath,
+  listDevicesFn,
+  listModelStatusesFn,
+  runWarmupFn
+}) {
+  const { exit } = useApp();
+  const [logs, setLogs] = useState5([]);
+  const [mode, setMode] = useState5("main");
+  const [mic, setMic] = useState5(null);
+  const [model, setModel] = useState5(null);
+  const addLog = useCallback2((message, type = "info") => {
+    setLogs((prev) => [...prev, { id: createLogId(), message, type }]);
+  }, []);
+  const { state, start, stop, cancel } = useRecorder({
+    workspaceRoot,
+    sessionId,
+    lincolnRecordPath,
+    mic,
+    model,
+    startOnMount: false
+  });
+  useEffect4(() => {
+    switch (state.status) {
+      case "recording":
+        addLog("Recording started.", "info");
+        break;
+      case "stopped":
+        addLog(`Saved to ${workspaceRoot}/${sessionId}/audio.wav`, "success");
+        addLog(`Run: claude process-interview ${sessionId}`, "command");
+        break;
+      case "cancelled":
+        addLog("Recording cancelled. No files were saved.", "error");
+        break;
+      case "error":
+        addLog(`Recording error: ${state.errorMessage ?? "unknown error"}`, "error");
+        break;
+    }
+  }, [state.status, state.errorMessage, addLog, workspaceRoot, sessionId]);
+  const handleQuit = useCallback2(() => {
+    exit();
+  }, [exit]);
+  const handleRecord = useCallback2(() => {
+    if (state.status === "idle") {
+      start();
+    }
+  }, [state.status, start]);
+  const handleStop = useCallback2(() => {
+    if (state.status === "recording") {
+      stop().catch(() => {
+      });
+    }
+  }, [state.status, stop]);
+  const handleCancel = useCallback2(() => {
+    if (state.status === "recording") {
+      cancel().catch(() => {
+      });
+    }
+  }, [state.status, cancel]);
+  const handleDevices = useCallback2(() => {
+    if (state.status === "idle") {
+      setMode("devices");
+    }
+  }, [state.status]);
+  const handleModel = useCallback2(() => {
+    if (state.status === "idle") {
+      setMode("model");
+    }
+  }, [state.status]);
+  const handleDeviceSelect = useCallback2(
+    (device) => {
+      setMic(device);
+      addLog(`Input device: ${device}`, "success");
+      setMode("main");
+    },
+    [addLog]
+  );
+  const handleModelSelect = useCallback2(
+    (name) => {
+      setModel(name);
+      addLog(`Model: ${name}`, "success");
+      setMode("main");
+    },
+    [addLog]
+  );
+  const handleMenuClose = useCallback2(() => {
+    setMode("main");
+  }, []);
+  const isTerminal = state.status === "stopped" || state.status === "cancelled" || state.status === "error";
+  useKeyHandler({
+    enabled: mode === "main",
+    onRecord: handleRecord,
+    onStop: handleStop,
+    onCancel: handleCancel,
+    onQuit: handleQuit,
+    onDevices: handleDevices,
+    onModel: handleModel,
+    onAnyKey: isTerminal ? handleQuit : void 0
+  });
+  const hintMode = useMemo(() => {
+    if (mode !== "main") return "menu";
+    if (state.status === "idle") return "idle";
+    if (state.status === "recording") return "recording";
+    if (state.status === "stopped") return "stopped";
+    if (state.status === "cancelled") return "cancelled";
+    return "error";
+  }, [mode, state.status]);
+  const devicesLoader = useCallback2(
+    () => (listDevicesFn ?? (() => listDevices(lincolnRecordPath)))(),
+    [listDevicesFn, lincolnRecordPath]
+  );
+  const modelsLoader = useCallback2(
+    () => (listModelStatusesFn ?? (() => Promise.resolve(listModelStatuses(defaultModelCacheDir()))))(),
+    [listModelStatusesFn]
+  );
+  const warmupRunner = useCallback2(
+    (name, onProgress) => runWarmupFn ? runWarmupFn(name, onProgress) : runWarmup({ model: name, lincolnRecordPath, onProgress }),
+    [runWarmupFn, lincolnRecordPath]
+  );
+  return /* @__PURE__ */ jsxs6(Box7, { flexDirection: "column", borderStyle: "round", borderColor: "gray", height: 24, children: [
+    /* @__PURE__ */ jsx7(
+      StatusPanel,
+      {
+        sessionId,
+        topic,
+        designId,
+        branch,
+        status: state.status,
+        duration: state.duration
+      }
+    ),
+    mode === "devices" && /* @__PURE__ */ jsx7(
+      DevicesMenu,
+      {
+        listDevicesFn: devicesLoader,
+        onSelect: handleDeviceSelect,
+        onClose: handleMenuClose
+      }
+    ),
+    mode === "model" && /* @__PURE__ */ jsx7(
+      ModelMenu,
+      {
+        listModelStatusesFn: modelsLoader,
+        runWarmupFn: warmupRunner,
+        onSelect: handleModelSelect,
+        onClose: handleMenuClose
+      }
+    ),
+    /* @__PURE__ */ jsx7(LogView, { logs }),
+    /* @__PURE__ */ jsx7(Box7, { flexGrow: 1 }),
+    /* @__PURE__ */ jsx7(HintBar, { mode: hintMode })
+  ] });
+}
+
+// src/cli.tsx
+import { jsx as jsx8, jsxs as jsxs7 } from "react/jsx-runtime";
+function App({ args, config }) {
+  if (args.help) {
+    return /* @__PURE__ */ jsxs7(Box8, { flexDirection: "column", padding: 1, children: [
+      /* @__PURE__ */ jsx8(Text7, { bold: true, children: "lincoln" }),
+      /* @__PURE__ */ jsx8(Text7, { children: "Cross-tool TUI for Lincoln interview recording." }),
+      /* @__PURE__ */ jsx8(Text7, {}),
+      /* @__PURE__ */ jsx8(Text7, { bold: true, children: "Usage:" }),
+      /* @__PURE__ */ jsx8(Text7, { children: "  lincoln [options]" }),
+      /* @__PURE__ */ jsx8(Text7, {}),
+      /* @__PURE__ */ jsx8(Text7, { bold: true, children: "Options:" }),
+      /* @__PURE__ */ jsx8(Text7, { children: "  --topic       Interview topic" }),
+      /* @__PURE__ */ jsx8(Text7, { children: "  --design-id   Design ID for the session" }),
+      /* @__PURE__ */ jsx8(Text7, { children: "  --branch      Current branch name" }),
+      /* @__PURE__ */ jsx8(Text7, { children: "  --session-id  Explicit session ID" }),
+      /* @__PURE__ */ jsx8(Text7, { children: "  --no-tui      Run without the terminal UI" }),
+      /* @__PURE__ */ jsx8(Text7, { children: "  --help, -h    Show this help message" }),
+      /* @__PURE__ */ jsx8(Text7, {}),
+      /* @__PURE__ */ jsx8(Text7, { dimColor: true, children: "Configuration files: ~/.lincolnrc, ./.lincolnrc" })
+    ] });
+  }
+  return /* @__PURE__ */ jsx8(
+    RecordingApp,
+    {
+      workspaceRoot: config.workspaceRoot,
+      sessionId: config.sessionId,
+      topic: config.topic,
+      designId: config.designId,
+      branch: config.branch,
+      audioMeterStyle: config.audioMeterStyle
+    }
+  );
+}
+async function main(argv = process.argv.slice(2)) {
+  const args = parseArgs(argv);
+  const config = resolveConfig(args);
+  if (args.noTui) {
+    console.log(JSON.stringify(config, null, 2));
+    return;
+  }
+  const { render } = await import("ink");
+  render(/* @__PURE__ */ jsx8(App, { args, config }));
+}
+
+// src/main.tsx
+main();
+//# sourceMappingURL=main.js.map