@lawaty/lacode 1.1.0 → 1.2.0

package/dist/tui.js

@@ -0,0 +1,1282 @@
+// src/voice/recorder.ts
+import { spawn } from "node:child_process";
+import { randomUUID } from "node:crypto";
+import { existsSync, readFileSync, unlinkSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+function createRecorder(deps) {
+  const spawnImpl = deps?.spawnImpl ?? spawn;
+  const tmpdirVal = deps?.tmpdir ?? tmpdir();
+  const maxSeconds = deps?.maxSeconds ?? 120;
+  const exists = deps?.exists ?? ((p) => {
+    try {
+      return existsSync(p);
+    } catch {
+      return false;
+    }
+  });
+  const readFile = deps?.readFile ?? ((p) => readFileSync(p));
+  const unlink = deps?.unlink ?? ((p) => {
+    unlinkSync(p);
+  });
+  const now = deps?.now ?? Date.now;
+  let chosenBin = deps?.bin;
+  let active = false;
+  let childHandle;
+  let currentPath;
+  let exited = false;
+  let resolveWait = null;
+  const recorder2 = {
+    get active() {
+      return active;
+    },
+    get path() {
+      return currentPath;
+    },
+    start() {
+      if (active) return;
+      if (chosenBin === void 0) {
+        if (exists("/usr/bin/arecord") || exists("/usr/local/bin/arecord") || exists("arecord")) {
+          chosenBin = "arecord";
+        } else {
+          chosenBin = "ffmpeg";
+        }
+      }
+      const bin = chosenBin;
+      currentPath = join(tmpdirVal, `lacode-voice-${process.pid}-${now()}-${randomUUID()}.wav`);
+      const path = currentPath;
+      const args = bin === "arecord" ? ["-q", "-f", "S16_LE", "-r", "16000", "-c", "1", "-t", "wav", "-d", String(maxSeconds), path] : ["-hide_banner", "-loglevel", "error", "-f", "pulse", "-i", "default", "-ar", "16000", "-ac", "1", "-t", String(maxSeconds), "-y", path];
+      exited = false;
+      let child;
+      try {
+        child = spawnImpl(bin, args, { stdio: "ignore" });
+      } catch {
+        active = false;
+        currentPath = void 0;
+        return;
+      }
+      childHandle = child;
+      active = true;
+      const onClose = () => {
+        exited = true;
+        if (resolveWait) {
+          const r = resolveWait;
+          resolveWait = null;
+          r();
+        }
+      };
+      try {
+        child.on("close", onClose);
+        child.on("exit", onClose);
+        child.on("error", (err) => {
+          exited = true;
+          if (resolveWait) {
+            const r = resolveWait;
+            resolveWait = null;
+            r();
+          }
+          active = false;
+        });
+      } catch {
+      }
+    },
+    async stop() {
+      if (!active || !childHandle) return void 0;
+      const child = childHandle;
+      const filePath = currentPath;
+      if (!exited) {
+        await new Promise((resolve) => {
+          let done = false;
+          let timer;
+          const finish = () => {
+            if (done) return;
+            done = true;
+            if (timer) clearTimeout(timer);
+            if (resolveWait === resolve) resolveWait = null;
+            resolve();
+          };
+          resolveWait = resolve;
+          timer = setTimeout(() => {
+            try {
+              child.kill("SIGKILL");
+            } catch {
+            }
+            finish();
+          }, 3e3);
+          try {
+            child.kill("SIGINT");
+          } catch {
+            finish();
+          }
+          if (exited) finish();
+        });
+      }
+      let result;
+      try {
+        if (filePath) {
+          const data = readFile(filePath);
+          if (data && data.length > 0) result = data;
+        }
+      } catch {
+        result = void 0;
+      } finally {
+        if (filePath) {
+          try {
+            unlink(filePath);
+          } catch {
+          }
+        }
+      }
+      childHandle = void 0;
+      currentPath = void 0;
+      active = false;
+      return result;
+    },
+    abort() {
+      const child = childHandle;
+      const filePath = currentPath;
+      if (child) {
+        try {
+          child.kill("SIGKILL");
+        } catch {
+        }
+      }
+      if (filePath) {
+        try {
+          unlink(filePath);
+        } catch {
+        }
+      }
+      childHandle = void 0;
+      currentPath = void 0;
+      active = false;
+      exited = true;
+      if (resolveWait) {
+        const r = resolveWait;
+        resolveWait = null;
+        r();
+      }
+    }
+  };
+  return recorder2;
+}
+
+// src/voice/groq.ts
+import { readFileSync as readFileSync2 } from "node:fs";
+import { homedir } from "node:os";
+import { join as join2 } from "node:path";
+var DEFAULT_READ_FILE = (p) => {
+  try {
+    return readFileSync2(p, "utf8");
+  } catch {
+    return null;
+  }
+};
+function resolveGroqKey(deps) {
+  const env = deps?.env ?? process.env;
+  const home = deps?.home ?? homedir();
+  const readFile = deps?.readFile ?? DEFAULT_READ_FILE;
+  const safeRead = (p) => {
+    try {
+      return readFile(p);
+    } catch {
+      return null;
+    }
+  };
+  const envVal = env?.GROQ_KEY;
+  if (typeof envVal === "string") {
+    const trimmed = envVal.trim();
+    if (trimmed !== "") return { key: trimmed, source: "env" };
+  }
+  const filePath = join2(home, ".config", "lacode", "voice.json");
+  const fileContent = safeRead(filePath);
+  if (typeof fileContent === "string") {
+    let parsed;
+    try {
+      parsed = JSON.parse(fileContent);
+    } catch {
+      parsed = void 0;
+    }
+    if (parsed && typeof parsed === "object") {
+      const obj = parsed;
+      const keys = ["groqKey", "GROQ_KEY", "apiKey", "groq_key"];
+      for (const k of keys) {
+        const v = obj[k];
+        if (typeof v === "string") {
+          const t = v.trim();
+          if (t !== "") return { key: t, source: "file" };
+        }
+      }
+    }
+  }
+  const bashFiles = [join2(home, ".bashrc"), join2(home, ".bash_profile"), join2(home, ".profile")];
+  const skipPatterns = ["$(", "`", "$GROQ", "$HOME"];
+  const regex = /^\s*(?:export\s+)?GROQ_KEY\s*=\s*(.+?)\s*$/;
+  for (const f of bashFiles) {
+    const content = safeRead(f);
+    if (typeof content !== "string") continue;
+    const lines = content.split(/\r?\n/);
+    for (const line of lines) {
+      const m = regex.exec(line);
+      if (!m) continue;
+      let value = m[1];
+      const isSingle = value.startsWith("'") && value.endsWith("'") && value.length >= 2;
+      const isDouble = value.startsWith('"') && value.endsWith('"') && value.length >= 2;
+      if (isSingle || isDouble) {
+        value = value.slice(1, -1);
+      } else {
+        value = value.replace(/\s+#.*$/, "");
+        value = value.trim();
+      }
+      let skip = false;
+      for (const p of skipPatterns) {
+        if (value.includes(p)) {
+          skip = true;
+          break;
+        }
+      }
+      if (skip) continue;
+      if (value === "") continue;
+      return { key: value, source: "bashrc" };
+    }
+  }
+  return void 0;
+}
+async function transcribe(input) {
+  if (!input.audio || input.audio.length === 0) {
+    throw new Error("no audio captured");
+  }
+  const filename = input.filename ?? "audio.wav";
+  const model = input.model ?? "whisper-large-v3-turbo";
+  const language = input.language ?? "en";
+  const baseUrl = input.baseUrl ?? "https://api.groq.com/openai/v1";
+  const timeoutMs = input.timeoutMs ?? 3e4;
+  const fetchImpl = input.fetchImpl ?? fetch;
+  const form = new FormData();
+  const blob = new Blob([input.audio], { type: "audio/wav" });
+  form.append("file", blob, filename);
+  form.append("model", model);
+  form.append("language", language);
+  form.append("temperature", "0");
+  form.append("response_format", "json");
+  if (input.prompt) form.append("prompt", input.prompt);
+  const url = `${baseUrl}/audio/transcriptions`;
+  const res = await fetchImpl(url, {
+    method: "POST",
+    headers: { Authorization: `Bearer ${input.key}` },
+    body: form,
+    signal: AbortSignal.timeout(timeoutMs)
+  });
+  if (!res.ok) {
+    try {
+      await res.text();
+    } catch {
+    }
+    throw new Error(`groq transcription failed (HTTP ${res.status})`);
+  }
+  let json;
+  try {
+    json = await res.json();
+  } catch {
+    return "";
+  }
+  const text = json?.text;
+  if (typeof text !== "string" || text.trim() === "") return "";
+  return text.trim();
+}
+
+// src/voice/parse.ts
+var NUMBER_WORDS = {
+  zero: 0,
+  one: 1,
+  two: 2,
+  three: 3,
+  four: 4,
+  five: 5,
+  six: 6,
+  seven: 7,
+  eight: 8,
+  nine: 9,
+  ten: 10,
+  first: 1,
+  second: 2,
+  third: 3,
+  fourth: 4,
+  fifth: 5,
+  sixth: 6,
+  seventh: 7,
+  eighth: 8,
+  ninth: 9,
+  tenth: 10
+};
+var STOPWORDS = /* @__PURE__ */ new Set(["the", "a", "an", "of", "to", "for", "and", "or", "option", "choice"]);
+function normalise(utterance) {
+  let s = utterance.toLowerCase();
+  s = s.replace(/&/g, " and ").replace(/\//g, " and ");
+  s = s.replace(/^[^\w\s]+|[^\w\s]+$/g, "");
+  s = s.replace(/\s+/g, " ").trim();
+  return s;
+}
+function stripPunct(w) {
+  return w.replace(/^[^\w']+|[^\w']+$/g, "");
+}
+function extractNumericTokens(utterance) {
+  const norm = normalise(utterance);
+  const words = norm.split(/[\s,]+/);
+  const tokens = [];
+  for (const raw of words) {
+    const w = stripPunct(raw);
+    if (w === "") continue;
+    if (/^\d+$/.test(w)) tokens.push(w);
+    else if (Object.prototype.hasOwnProperty.call(NUMBER_WORDS, w)) tokens.push(w);
+    else if (w === "last") tokens.push(w);
+  }
+  return tokens;
+}
+function matchLabel(norm, question) {
+  if (norm === "") return null;
+  const opts = question.options;
+  const lower = (s) => s.toLowerCase().trim();
+  for (let i = 0; i < opts.length; i++) {
+    if (lower(opts[i].label) === norm) return i;
+  }
+  for (let i = 0; i < opts.length; i++) {
+    const lab = lower(opts[i].label);
+    if (lab.length === 0) continue;
+    if (norm.startsWith(lab) || lab.startsWith(norm)) return i;
+  }
+  const utteranceWords = new Set(
+    norm.split(/[\s,]+/).map((w) => stripPunct(w)).filter((w) => w.length > 0)
+  );
+  let best = -1;
+  let bestCount = 0;
+  for (let i = 0; i < opts.length; i++) {
+    const sig = lower(opts[i].label).split(/[\s\W]+/).filter((w) => w.length > 2 && !STOPWORDS.has(w));
+    const unique = [...new Set(sig)];
+    if (unique.length === 0) continue;
+    if (unique.every((w) => utteranceWords.has(w))) {
+      if (unique.length > bestCount) {
+        bestCount = unique.length;
+        best = i;
+      }
+    }
+  }
+  return best === -1 ? null : best;
+}
+function parseSelection(utterance, question) {
+  const norm = normalise(utterance);
+  const options = question.options;
+  const n = options.length;
+  const words = norm.split(/[\s,]+/);
+  let numericFound = false;
+  const rawIndices = [];
+  for (const raw of words) {
+    const w = stripPunct(raw);
+    if (w === "") continue;
+    if (/^\d+$/.test(w)) {
+      numericFound = true;
+      rawIndices.push(parseInt(w, 10) - 1);
+    } else if (Object.prototype.hasOwnProperty.call(NUMBER_WORDS, w)) {
+      numericFound = true;
+      rawIndices.push(NUMBER_WORDS[w] - 1);
+    } else if (w === "last") {
+      numericFound = true;
+      rawIndices.push(n - 1);
+    }
+  }
+  let matched = false;
+  const indices = [];
+  const seen = /* @__PURE__ */ new Set();
+  if (numericFound) {
+    matched = true;
+    for (const idx of rawIndices) {
+      if (idx >= 0 && idx < n && !seen.has(idx)) {
+        seen.add(idx);
+        indices.push(idx);
+      }
+    }
+  } else if (/\b(all|everything|both|any)\b/.test(norm)) {
+    matched = true;
+    if (question.multiple) {
+      for (let i = 0; i < n; i++) {
+        if (!seen.has(i)) {
+          seen.add(i);
+          indices.push(i);
+        }
+      }
+    } else if (n > 0) {
+      seen.add(0);
+      indices.push(0);
+    }
+  } else if (/\b(none|nothing|skip|neither)\b/.test(norm)) {
+    matched = true;
+  } else {
+    const m = matchLabel(norm, question);
+    if (m !== null) {
+      matched = true;
+      if (m >= 0 && m < n && !seen.has(m)) {
+        seen.add(m);
+        indices.push(m);
+      }
+    }
+  }
+  let result = indices;
+  if (!question.multiple && result.length > 1) {
+    result = result.length > 0 ? [result[0]] : [];
+  }
+  if (result.length === 0 && !matched && question.custom === true) {
+    return [-1];
+  }
+  return result;
+}
+function mapSelection(sel, question, utterance) {
+  const out = [];
+  for (const idx of sel) {
+    if (idx === -1) out.push(utterance.trim());
+    else if (idx >= 0 && idx < question.options.length) out.push(question.options[idx].label);
+  }
+  return out;
+}
+function parseQuestionAnswers(utterance, questions) {
+  if (questions.length === 0) return [];
+  if (questions.length === 1) {
+    const sel2 = parseSelection(utterance, questions[0]);
+    return [mapSelection(sel2, questions[0], utterance)];
+  }
+  const tokens = extractNumericTokens(utterance);
+  if (tokens.length === questions.length) {
+    const res2 = [];
+    for (let i = 0; i < questions.length; i++) {
+      const sel2 = parseSelection(tokens[i], questions[i]);
+      res2.push(mapSelection(sel2, questions[i], utterance));
+    }
+    return res2;
+  }
+  const sel = parseSelection(utterance, questions[0]);
+  const res = [mapSelection(sel, questions[0], utterance)];
+  for (let i = 1; i < questions.length; i++) res.push([]);
+  return res;
+}
+function parsePermissionReply(utterance) {
+  const norm = normalise(utterance);
+  const padded = ` ${norm} `;
+  const alwaysPhrases = [
+    "always",
+    "always allow",
+    "allow always",
+    "never ask",
+    "dont ask again",
+    "don't ask again",
+    "permanent",
+    "permanently"
+  ];
+  const oncePhrases = [
+    "yes",
+    "yeah",
+    "yep",
+    "ok",
+    "okay",
+    "allow",
+    "approve",
+    "go",
+    "go ahead",
+    "proceed",
+    "do it",
+    "sure",
+    "fine",
+    "accept"
+  ];
+  const rejectPhrases = [
+    "no",
+    "nope",
+    "nah",
+    "deny",
+    "reject",
+    "refuse",
+    "cancel",
+    "stop",
+    "abort",
+    "decline",
+    "don't",
+    "do not"
+  ];
+  for (const p of alwaysPhrases) {
+    if (padded.includes(` ${p} `)) return "always";
+  }
+  for (const p of oncePhrases) {
+    if (padded.includes(` ${p} `)) return "once";
+  }
+  for (const p of rejectPhrases) {
+    if (padded.includes(` ${p} `)) return "reject";
+  }
+  return void 0;
+}
+var cleanTranscript = (text) => /[a-z0-9]/i.test(text) ? text.trim() : "";
+
+// src/voice/audio.ts
+function readU16(bytes, off) {
+  return bytes[off] | bytes[off + 1] << 8;
+}
+function readU32(bytes, off) {
+  return (bytes[off] | bytes[off + 1] << 8 | bytes[off + 2] << 16 | bytes[off + 3] << 24) >>> 0;
+}
+function pcmStats(pcm, sampleRate = 16e3) {
+  const samples = pcm ? pcm.length : 0;
+  let sumSq = 0;
+  let peak = 0;
+  if (pcm) {
+    for (let i = 0; i < pcm.length; i++) {
+      const v = pcm[i];
+      sumSq += v * v;
+      const a = v < 0 ? -v : v;
+      if (a > peak) peak = a;
+    }
+  }
+  const rms = samples === 0 ? 0 : Math.sqrt(sumSq / samples);
+  const durationMs = sampleRate > 0 ? samples / sampleRate * 1e3 : 0;
+  return { samples, durationMs, rms, peak };
+}
+function hasSpeech(pcm, options) {
+  const sampleRate = options?.sampleRate ?? 16e3;
+  const minDurationMs = options?.minDurationMs ?? 250;
+  const minRms = options?.minRms ?? 400;
+  const minPeak = options?.minPeak ?? 1500;
+  const stats = pcmStats(pcm, sampleRate);
+  return stats.durationMs >= minDurationMs && stats.rms >= minRms && stats.peak >= minPeak;
+}
+var SILENCE_HALLUCINATIONS = /* @__PURE__ */ new Set([
+  "thank you",
+  "thanks",
+  "thanks for watching",
+  "thank you for watching",
+  "thank you for watching!",
+  "you",
+  "bye",
+  "bye bye",
+  "please subscribe",
+  "subscribe",
+  "amara.org",
+  "subtitles by",
+  "the end",
+  "okay",
+  "ok"
+]);
+function isSilenceHallucination(text, durationMs) {
+  const normalised = String(text).toLowerCase().replace(/[^a-z0-9.\s]/g, "").replace(/\s+/g, " ").trim().replace(/\.$/, "");
+  return durationMs < 3e3 && SILENCE_HALLUCINATIONS.has(normalised);
+}
+function decodeWavPcm(bytes) {
+  if (!bytes || bytes.length < 12) return void 0;
+  if (bytes[0] !== 82 || bytes[1] !== 73 || bytes[2] !== 70 || bytes[3] !== 70) return void 0;
+  if (bytes[8] !== 87 || bytes[9] !== 65 || bytes[10] !== 86 || bytes[11] !== 69) return void 0;
+  let off = 12;
+  const total = bytes.length;
+  let fmtFound = false;
+  let audioFormat = 0;
+  let channels = 0;
+  let sampleRate = 0;
+  let bitsPerSample = 0;
+  let dataOffset = -1;
+  let dataSize = 0;
+  let dataFound = false;
+  while (off + 8 <= total) {
+    const id = String.fromCharCode(bytes[off], bytes[off + 1], bytes[off + 2], bytes[off + 3]);
+    const size = readU32(bytes, off + 4);
+    const chunkStart = off + 8;
+    if (chunkStart > total) return void 0;
+    if (size > total - chunkStart) return void 0;
+    if (id === "fmt ") {
+      if (size < 16) return void 0;
+      if (chunkStart + 16 > total) return void 0;
+      audioFormat = readU16(bytes, chunkStart);
+      channels = readU16(bytes, chunkStart + 2);
+      sampleRate = readU32(bytes, chunkStart + 4);
+      bitsPerSample = readU16(bytes, chunkStart + 14);
+      fmtFound = true;
+    } else if (id === "data" && !dataFound) {
+      dataOffset = chunkStart;
+      dataSize = size;
+      dataFound = true;
+    }
+    let advance = 8 + size;
+    if (size % 2 === 1) advance += 1;
+    if (advance < 8) return void 0;
+    off += advance;
+    if (off > total) return void 0;
+  }
+  if (!fmtFound) return void 0;
+  if (!dataFound) return void 0;
+  if (audioFormat !== 1) return void 0;
+  if (bitsPerSample !== 16) return void 0;
+  if (channels < 1 || channels > 2) return void 0;
+  if (sampleRate <= 0) return void 0;
+  if (dataOffset < 0) return void 0;
+  if (dataOffset + dataSize > total) return void 0;
+  const sampleCount = Math.floor(dataSize / 2);
+  const pcm = new Int16Array(sampleCount);
+  const view = new DataView(bytes.buffer, bytes.byteOffset + dataOffset, sampleCount * 2);
+  for (let i = 0; i < sampleCount; i++) {
+    pcm[i] = view.getInt16(i * 2, true);
+  }
+  return { pcm, sampleRate, channels };
+}
+
+// src/voice/transport.ts
+import * as nodeNet from "node:net";
+
+// src/voice/protocol.ts
+var VOICE_PROTOCOL_VERSION = 1;
+function isRecord(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function toText(line) {
+  return typeof line === "string" ? line : line.toString("utf8");
+}
+function normalizeLine(line) {
+  let s = toText(line);
+  if (s.endsWith("\n")) s = s.slice(0, -1);
+  if (s.endsWith("\r")) s = s.slice(0, -1);
+  return s;
+}
+function encodeMessage(message) {
+  return JSON.stringify(message) + "\n";
+}
+function decodeDaemonMessage(line) {
+  const text = normalizeLine(line);
+  if (text.trim() === "") return void 0;
+  let parsed;
+  try {
+    parsed = JSON.parse(text);
+  } catch {
+    return void 0;
+  }
+  if (!isRecord(parsed)) return void 0;
+  const t = parsed.t;
+  switch (t) {
+    case "welcome": {
+      if (typeof parsed.v !== "number") return void 0;
+      if (typeof parsed.armed !== "boolean") return void 0;
+      if (typeof parsed.wake !== "boolean") return void 0;
+      return { t: "welcome", v: parsed.v, armed: parsed.armed, wake: parsed.wake };
+    }
+    case "state": {
+      if (typeof parsed.armed !== "boolean") return void 0;
+      if (parsed.phase !== "idle" && parsed.phase !== "recording" && parsed.phase !== "transcribing") return void 0;
+      return { t: "state", armed: parsed.armed, phase: parsed.phase };
+    }
+    case "transcript": {
+      if (typeof parsed.text !== "string") return void 0;
+      if (parsed.source !== "wake" && parsed.source !== "manual") return void 0;
+      return { t: "transcript", text: parsed.text, source: parsed.source };
+    }
+    case "error": {
+      if (typeof parsed.message !== "string") return void 0;
+      return { t: "error", message: parsed.message };
+    }
+    case "pong":
+      return { t: "pong" };
+    default:
+      return void 0;
+  }
+}
+function createLineDecoder(decode) {
+  const MAX_LINE = 64 * 1024;
+  let buffer = "";
+  return (chunk) => {
+    const text = typeof chunk === "string" ? chunk : chunk.toString("utf8");
+    buffer += text;
+    const out = [];
+    while (true) {
+      const idx = buffer.indexOf("\n");
+      if (idx === -1) break;
+      const line = buffer.slice(0, idx);
+      buffer = buffer.slice(idx + 1);
+      if (line.length > MAX_LINE) {
+        buffer = "";
+        break;
+      }
+      const msg = decode(line);
+      if (msg !== void 0) out.push(msg);
+    }
+    if (buffer.length > MAX_LINE) {
+      buffer = "";
+    }
+    return out;
+  };
+}
+
+// src/voice/transport.ts
+function createVoiceClient(options, deps) {
+  const port = options.port ?? 8765;
+  const host = options.host ?? "127.0.0.1";
+  const onMessage = options.onMessage;
+  const onConnectionChange = options.onConnectionChange;
+  const reconnectMs = options.reconnectMs ?? 2e3;
+  const netMod = deps && deps.net ? deps.net : nodeNet;
+  let socket;
+  let connected = false;
+  let stopped = false;
+  let timer;
+  let decoder = createLineDecoder(decodeDaemonMessage);
+  const setConnected = (value) => {
+    if (connected === value) return;
+    connected = value;
+    try {
+      onConnectionChange?.(value);
+    } catch {
+    }
+  };
+  const scheduleReconnect = () => {
+    if (stopped) return;
+    if (timer) return;
+    timer = setTimeout(() => {
+      timer = void 0;
+      connect();
+    }, reconnectMs);
+    try {
+      timer.unref?.();
+    } catch {
+    }
+  };
+  const connect = () => {
+    if (stopped) return;
+    if (socket && !socket.destroyed) return;
+    decoder = createLineDecoder(decodeDaemonMessage);
+    let sock;
+    try {
+      sock = netMod.createConnection({ port, host });
+    } catch {
+      socket = void 0;
+      scheduleReconnect();
+      return;
+    }
+    socket = sock;
+    sock.on("connect", () => {
+      setConnected(true);
+    });
+    sock.on("data", (chunk) => {
+      try {
+        const msgs = decoder(chunk);
+        for (const m of msgs) {
+          try {
+            onMessage?.(m);
+          } catch {
+          }
+        }
+      } catch {
+      }
+    });
+    sock.on("close", () => {
+      socket = void 0;
+      setConnected(false);
+      scheduleReconnect();
+    });
+    sock.on("error", () => {
+      setConnected(false);
+      try {
+        sock.destroy();
+      } catch {
+      }
+      socket = void 0;
+      scheduleReconnect();
+    });
+  };
+  const client = {
+    get connected() {
+      return connected;
+    },
+    start() {
+      stopped = false;
+      connect();
+    },
+    stop() {
+      if (stopped && !socket && !timer) {
+      }
+      stopped = true;
+      if (timer) {
+        clearTimeout(timer);
+        timer = void 0;
+      }
+      if (socket) {
+        try {
+          socket.destroy();
+        } catch {
+        }
+        socket = void 0;
+      }
+      setConnected(false);
+    },
+    send(message) {
+      try {
+        if (stopped) return false;
+        if (!socket || socket.destroyed || !socket.writable) return false;
+        if (!connected) return false;
+        socket.write(encodeMessage(message));
+        return true;
+      } catch {
+        return false;
+      }
+    }
+  };
+  return client;
+}
+
+// src/tui/index.ts
+var DEFAULT_MODEL = "whisper-large-v3-turbo";
+var DEFAULT_LANGUAGE = "en";
+var DEFAULT_MAX_SECONDS = 120;
+var DEFAULT_DICTATE_KEY = "<leader>v";
+var DEFAULT_ANSWER_KEY = "<leader>a";
+var DEFAULT_DAEMON_PORT = 8765;
+var DEFAULT_DAEMON_HOST = "127.0.0.1";
+var SETUP_HINT = 'Set GROQ_KEY or create ~/.config/lacode/voice.json with {"groqKey":"..."}';
+var daemonConnected = false;
+var recordingPulse;
+var recorder;
+var phase = "idle";
+var activeMode;
+var activeRequest;
+function resetState() {
+  phase = "idle";
+  activeMode = void 0;
+  activeRequest = void 0;
+}
+function resolveOptions(options) {
+  const o = options ?? {};
+  const intent = o.intent === "insert" || o.intent === "answer" || o.intent === "auto" ? o.intent : "auto";
+  return {
+    enabled: o.enabled !== false,
+    dictation: o.dictation !== false,
+    answers: o.answers !== false,
+    submit: o.submit === true,
+    model: typeof o.model === "string" && o.model.length > 0 ? o.model : DEFAULT_MODEL,
+    language: typeof o.language === "string" && o.language.length > 0 ? o.language : DEFAULT_LANGUAGE,
+    vocabulary: typeof o.vocabulary === "string" && o.vocabulary.length > 0 ? o.vocabulary : void 0,
+    maxSeconds: typeof o.maxSeconds === "number" && Number.isFinite(o.maxSeconds) && o.maxSeconds > 0 ? o.maxSeconds : DEFAULT_MAX_SECONDS,
+    dictateKey: typeof o.dictateKey === "string" && o.dictateKey.length > 0 ? o.dictateKey : DEFAULT_DICTATE_KEY,
+    answerKey: typeof o.answerKey === "string" && o.answerKey.length > 0 ? o.answerKey : DEFAULT_ANSWER_KEY,
+    useDaemon: o.useDaemon !== false,
+    daemonPort: typeof o.daemonPort === "number" && Number.isFinite(o.daemonPort) && o.daemonPort > 0 ? o.daemonPort : DEFAULT_DAEMON_PORT,
+    daemonHost: typeof o.daemonHost === "string" && o.daemonHost.length > 0 ? o.daemonHost : DEFAULT_DAEMON_HOST,
+    intent
+  };
+}
+function toast(api, input) {
+  api.ui.toast(input);
+}
+var stopRecordingIndicator = () => {
+  if (!recordingPulse) return;
+  clearInterval(recordingPulse);
+  recordingPulse = void 0;
+};
+var startRecordingIndicator = (api, message = "\u25CF Recording\u2026") => {
+  stopRecordingIndicator();
+  const show = () => {
+    try {
+      toast(api, { variant: "info", title: "lacode voice", message, duration: 5e3 });
+    } catch {
+    }
+  };
+  show();
+  recordingPulse = setInterval(show, 4e3);
+  recordingPulse.unref?.();
+};
+function readableError(err) {
+  if (err instanceof Error) return err.message;
+  if (typeof err === "string") return err;
+  if (err && typeof err === "object") {
+    const message = err.message;
+    if (typeof message === "string" && message.length > 0) return message;
+    try {
+      return JSON.stringify(err);
+    } catch {
+      return String(err);
+    }
+  }
+  return String(err);
+}
+function unwrapList(result) {
+  if (Array.isArray(result)) return result;
+  if (result && typeof result === "object") {
+    const envelope = result;
+    if (envelope.error !== void 0 && envelope.error !== null) {
+      throw new Error(readableError(envelope.error));
+    }
+    if (Array.isArray(envelope.data)) return envelope.data;
+  }
+  return [];
+}
+function ensureOk(result) {
+  if (!result || typeof result !== "object" || !("error" in result)) return;
+  const error = result.error;
+  if (error !== void 0 && error !== null) throw new Error(readableError(error));
+}
+async function fetchPending(api) {
+  const [questions, permissions] = await Promise.all([
+    api.client.question.list(),
+    api.client.permission.list()
+  ]);
+  const pending = [];
+  for (const request of unwrapList(questions)) {
+    pending.push({ kind: "question", request });
+  }
+  for (const request of unwrapList(permissions)) {
+    pending.push({ kind: "permission", request });
+  }
+  return pending;
+}
+async function stillPending(api, request) {
+  const pending = await fetchPending(api);
+  return pending.some((entry) => entry.request.id === request.request.id);
+}
+function toParsedQuestions(request) {
+  return (request.questions ?? []).map((question) => ({
+    options: (question.options ?? []).map((option) => ({ label: option.label })),
+    multiple: question.multiple,
+    custom: question.custom
+  }));
+}
+async function stopAndComplete(api, opts) {
+  const mode = activeMode;
+  const request = activeRequest;
+  stopRecordingIndicator();
+  toast(api, { variant: "info", title: "lacode voice", message: "Transcribing\u2026", duration: 1500 });
+  try {
+    const bytes = await recorder.stop();
+    if (mode === "dictate") {
+      await finishDictate(api, opts, bytes);
+    } else if (mode === "answer" && request) {
+      await finishAnswer(api, opts, bytes, request);
+    }
+  } finally {
+    stopRecordingIndicator();
+    resetState();
+  }
+}
+async function finishDictate(api, opts, bytes) {
+  if (!bytes || bytes.length === 0) {
+    toast(api, { variant: "warning", message: "No audio captured" });
+    return;
+  }
+  const decoded = decodeWavPcm(bytes);
+  if (!decoded || !hasSpeech(decoded.pcm, { sampleRate: decoded.sampleRate })) {
+    api.ui.toast({ variant: "warning", title: "lacode voice", message: "No speech detected" });
+    return;
+  }
+  const resolved = resolveGroqKey();
+  if (!resolved) {
+    toast(api, { variant: "warning", message: SETUP_HINT });
+    return;
+  }
+  const text = cleanTranscript(await transcribe({
+    audio: bytes,
+    key: resolved.key,
+    model: opts.model,
+    language: opts.language,
+    prompt: opts.vocabulary
+  }));
+  if (isSilenceHallucination(text, decoded.pcm.length / decoded.sampleRate * 1e3)) {
+    api.ui.toast({ variant: "warning", title: "lacode voice", message: "No speech detected" });
+    return;
+  }
+  if (text.trim().length === 0) {
+    toast(api, { variant: "warning", message: "Nothing transcribed" });
+    return;
+  }
+  await api.client.tui.appendPrompt({ text });
+  if (opts.submit) await api.client.tui.submitPrompt();
+  toast(api, { variant: "success", message: text.slice(0, 60) });
+}
+async function finishAnswer(api, opts, bytes, request) {
+  if (!bytes || bytes.length === 0) {
+    toast(api, { variant: "warning", message: "No audio captured" });
+    return;
+  }
+  const decoded = decodeWavPcm(bytes);
+  if (!decoded || !hasSpeech(decoded.pcm, { sampleRate: decoded.sampleRate })) {
+    api.ui.toast({ variant: "warning", title: "lacode voice", message: "No speech detected" });
+    return;
+  }
+  const resolved = resolveGroqKey();
+  if (!resolved) {
+    toast(api, { variant: "warning", message: SETUP_HINT });
+    return;
+  }
+  const text = cleanTranscript(await transcribe({
+    audio: bytes,
+    key: resolved.key,
+    model: opts.model,
+    language: opts.language,
+    prompt: opts.vocabulary
+  }));
+  if (isSilenceHallucination(text, decoded.pcm.length / decoded.sampleRate * 1e3)) {
+    api.ui.toast({ variant: "warning", title: "lacode voice", message: "No speech detected" });
+    return;
+  }
+  await answerWithText(api, opts, text, request);
+}
+async function insertText(api, opts, text) {
+  await api.client.tui.appendPrompt({ text });
+  if (opts.submit) await api.client.tui.submitPrompt();
+  toast(api, { variant: "success", message: text.slice(0, 60) });
+}
+async function answerWithText(api, opts, text, request) {
+  if (request.kind === "permission") {
+    const reply = parsePermissionReply(text);
+    if (!reply) {
+      toast(api, { variant: "warning", message: "Couldn't match yes / always / no" });
+      return;
+    }
+    if (!await stillPending(api, request)) {
+      toast(api, { variant: "warning", message: "Request is no longer pending" });
+      return;
+    }
+    ensureOk(await api.client.permission.reply({ requestID: request.request.id, reply }));
+    toast(api, { variant: "success", message: `Permission: ${reply}` });
+    return;
+  }
+  const answers = parseQuestionAnswers(text, toParsedQuestions(request.request));
+  const allEmpty = answers.every((answer) => !answer || answer.length === 0);
+  if (allEmpty) {
+    toast(api, { variant: "warning", message: "Couldn't match an option" });
+    return;
+  }
+  if (!await stillPending(api, request)) {
+    toast(api, { variant: "warning", message: "Request is no longer pending" });
+    return;
+  }
+  ensureOk(await api.client.question.reply({ requestID: request.request.id, answers }));
+  const labels = answers.map((answer) => answer.join(", ")).filter((answer) => answer.length > 0).join("; ");
+  toast(api, { variant: "success", message: labels });
+}
+var tui = async (api, options) => {
+  const opts = resolveOptions(options);
+  if (!opts.enabled) return;
+  daemonConnected = false;
+  resetState();
+  const rawOptions = options ?? {};
+  let activeRecorder;
+  if (typeof rawOptions.recorder === "function") {
+    activeRecorder = rawOptions.recorder();
+  } else if (rawOptions.recorder && typeof rawOptions.recorder.start === "function") {
+    activeRecorder = rawOptions.recorder;
+  } else if (typeof rawOptions.createRecorder === "function") {
+    activeRecorder = rawOptions.createRecorder({ maxSeconds: opts.maxSeconds });
+  } else {
+    activeRecorder = createRecorder({ maxSeconds: opts.maxSeconds });
+  }
+  recorder = activeRecorder;
+  api.lifecycle.onDispose(() => activeRecorder.abort());
+  api.lifecycle.onDispose(() => stopRecordingIndicator());
+  let forcedIntent;
+  const handleTranscript = async (text, source) => {
+    const cleaned = cleanTranscript(text);
+    if (cleaned.length === 0) return;
+    let intent;
+    if (forcedIntent) {
+      intent = forcedIntent;
+      forcedIntent = void 0;
+    } else if (opts.intent === "insert" || opts.intent === "answer") {
+      intent = opts.intent;
+    } else {
+      intent = "auto";
+    }
+    try {
+      const pending = await fetchPending(api);
+      if (intent === "answer") {
+        if (pending.length === 0) {
+          await insertText(api, opts, cleaned);
+          return;
+        }
+        if (pending.length > 1) {
+          toast(api, {
+            variant: "warning",
+            message: "Several requests are pending \u2014 answer with the keyboard"
+          });
+          return;
+        }
+        await answerWithText(api, opts, cleaned, pending[0]);
+        return;
+      }
+      if (intent === "auto") {
+        if (pending.length === 1) {
+          await answerWithText(api, opts, cleaned, pending[0]);
+          return;
+        }
+        await insertText(api, opts, cleaned);
+        return;
+      }
+      await insertText(api, opts, cleaned);
+    } catch (err) {
+      toast(api, { variant: "error", title: "lacode voice", message: readableError(err) });
+    }
+  };
+  let daemon;
+  if (opts.useDaemon) {
+    daemon = createVoiceClient({
+      port: opts.daemonPort,
+      host: opts.daemonHost,
+      onMessage: (message) => {
+        try {
+          if (message.t === "state") {
+            if (message.phase === "recording") {
+              startRecordingIndicator(api);
+            } else if (message.phase === "transcribing") {
+              stopRecordingIndicator();
+              toast(api, {
+                variant: "info",
+                title: "lacode voice",
+                message: "Transcribing\u2026",
+                duration: 1500
+              });
+            } else if (message.phase === "idle") {
+              stopRecordingIndicator();
+            }
+          } else if (message.t === "transcript") {
+            void handleTranscript(message.text, message.source);
+          } else if (message.t === "error") {
+            stopRecordingIndicator();
+            toast(api, { variant: "error", title: "lacode voice", message: message.message });
+          }
+        } catch (err) {
+          stopRecordingIndicator();
+          toast(api, { variant: "error", title: "lacode voice", message: readableError(err) });
+        }
+      },
+      onConnectionChange: (connected) => {
+        daemonConnected = connected;
+        if (connected && daemon) {
+          daemon.send({ t: "hello", v: VOICE_PROTOCOL_VERSION, client: "tui" });
+        }
+      }
+    });
+    daemon.start();
+    api.lifecycle.onDispose(() => daemon.stop());
+  }
+  const runDictate = async () => {
+    try {
+      if (!opts.dictation) {
+        toast(api, { variant: "warning", message: "Voice dictation is disabled" });
+        return;
+      }
+      if (daemonConnected && daemon) {
+        forcedIntent = "insert";
+        daemon.send({ t: "toggle" });
+        return;
+      }
+      if (phase === "recording") {
+        await stopAndComplete(api, opts);
+        return;
+      }
+      const resolved = resolveGroqKey();
+      if (!resolved) {
+        toast(api, { variant: "warning", message: SETUP_HINT });
+        return;
+      }
+      recorder.start();
+      phase = "recording";
+      activeMode = "dictate";
+      activeRequest = void 0;
+      startRecordingIndicator(api, "\u25CF Recording\u2026 press the key again to stop");
+    } catch (err) {
+      stopRecordingIndicator();
+      resetState();
+      toast(api, { variant: "error", title: "lacode voice", message: readableError(err) });
+    }
+  };
+  const runAnswer = async () => {
+    try {
+      if (!opts.answers) {
+        toast(api, { variant: "warning", message: "Voice answers are disabled" });
+        return;
+      }
+      if (daemonConnected && daemon) {
+        const pending2 = await fetchPending(api);
+        if (pending2.length === 0) {
+          toast(api, { variant: "warning", message: "No pending question or permission" });
+          return;
+        }
+        forcedIntent = "answer";
+        daemon.send({ t: "toggle" });
+        return;
+      }
+      if (phase === "recording") {
+        await stopAndComplete(api, opts);
+        return;
+      }
+      const pending = await fetchPending(api);
+      if (pending.length === 0) {
+        toast(api, { variant: "warning", message: "No pending question or permission" });
+        return;
+      }
+      if (pending.length > 1) {
+        toast(api, {
+          variant: "warning",
+          message: "Several requests are pending \u2014 answer with the keyboard"
+        });
+        return;
+      }
+      activeRequest = pending[0];
+      recorder.start();
+      phase = "recording";
+      activeMode = "answer";
+      startRecordingIndicator(api, "\u25CF Recording\u2026 press the key again to stop");
+    } catch (err) {
+      stopRecordingIndicator();
+      resetState();
+      toast(api, { variant: "error", title: "lacode voice", message: readableError(err) });
+    }
+  };
+  const runCheck = async () => {
+    try {
+      const resolved = resolveGroqKey();
+      const daemonStatus = daemonConnected ? `daemon: connected (${opts.daemonPort})` : `daemon: not running (${opts.daemonPort})`;
+      if (resolved) {
+        toast(api, { variant: "success", message: `Groq key found (${resolved.source}); ${daemonStatus}` });
+        return;
+      }
+      toast(api, { variant: "warning", message: `${SETUP_HINT}; ${daemonStatus}` });
+    } catch (err) {
+      toast(api, { variant: "error", title: "lacode voice", message: readableError(err) });
+    }
+  };
+  const commands = [
+    {
+      name: "lacode.voice.dictate",
+      title: "Voice: dictate",
+      category: "Voice",
+      namespace: "palette",
+      run: async () => runDictate()
+    },
+    {
+      name: "lacode.voice.answer",
+      title: "Voice: answer question or permission",
+      category: "Voice",
+      namespace: "palette",
+      run: async () => runAnswer()
+    },
+    {
+      name: "lacode.voice.check",
+      title: "Voice: check setup",
+      category: "Voice",
+      namespace: "palette",
+      run: async () => runCheck()
+    }
+  ];
+  const bindings = [];
+  if (opts.dictation) {
+    bindings.push({ key: opts.dictateKey, cmd: "lacode.voice.dictate", desc: "Voice dictate" });
+  }
+  if (opts.answers) {
+    bindings.push({ key: opts.answerKey, cmd: "lacode.voice.answer", desc: "Voice answer" });
+  }
+  api.keymap.registerLayer({ mode: "base", commands, bindings });
+};
+var mod = {
+  id: "lacode.voice",
+  tui
+};
+var index_default = mod;
+export {
+  index_default as default
+};