picocode 0.9.202 → 0.9.204

package/dist/linux-dictate.js

@@ -0,0 +1,249 @@
+#!/usr/bin/env node
+
+// helper/linux-dictate.js
+import { spawn as nodeSpawn } from "node:child_process";
+import * as fs from "node:fs/promises";
+import { constants } from "node:fs";
+import { homedir, tmpdir } from "node:os";
+import { delimiter, join, resolve } from "node:path";
+import { fileURLToPath } from "node:url";
+import { createInterface } from "node:readline";
+function wavHeader(bytes) {
+  const header = Buffer.alloc(44);
+  header.write("RIFF");
+  header.writeUInt32LE(bytes + 36, 4);
+  header.write("WAVEfmt ", 8);
+  header.writeUInt32LE(16, 16);
+  header.writeUInt16LE(1, 20);
+  header.writeUInt16LE(1, 22);
+  header.writeUInt32LE(16e3, 24);
+  header.writeUInt32LE(32e3, 28);
+  header.writeUInt16LE(2, 32);
+  header.writeUInt16LE(16, 34);
+  header.write("data", 36);
+  header.writeUInt32LE(bytes, 40);
+  return header;
+}
+async function findExecutable(name, env = process.env) {
+  const paths = name.includes("/") ? [name] : (env.PATH || "").split(delimiter).map((dir) => join(dir, name));
+  for (const path of paths) {
+    try {
+      await fs.access(path, constants.X_OK);
+      return path;
+    } catch {
+    }
+  }
+  return null;
+}
+function createLinuxDictation({
+  emit = () => {
+  },
+  spawn = nodeSpawn,
+  env = process.env,
+  executable = (name) => findExecutable(name, env),
+  files = fs,
+  tempRoot = tmpdir(),
+  maxRecordingMs = 12e4,
+  killTimeoutMs = 1e3
+} = {}) {
+  const model = env.PICO_WHISPER_MODEL || join(env.XDG_CACHE_HOME || join(homedir(), ".cache"), "pico/whisper/ggml-base.en.bin");
+  let active = null;
+  let disposed = false;
+  const jobs = /* @__PURE__ */ new Set();
+  const send = (message) => {
+    if (!disposed) emit(message);
+  };
+  function launch(binary, args) {
+    const child = spawn(binary, args, { stdio: ["ignore", "pipe", "pipe"] });
+    const job = { child, error: null, stderr: "", done: false };
+    jobs.add(job);
+    child.stderr?.on("data", (chunk) => {
+      job.stderr = (job.stderr + chunk.toString()).slice(-4096);
+    });
+    job.closed = new Promise((resolve2) => {
+      child.once("error", (error) => {
+        job.error = error;
+        finish(null);
+      });
+      child.once("close", (code) => finish(code));
+      function finish(code) {
+        if (job.done) return;
+        job.done = true;
+        jobs.delete(job);
+        resolve2(code);
+      }
+    });
+    job.started = new Promise((resolve2, reject) => {
+      child.once("spawn", resolve2);
+      child.once("error", reject);
+    });
+    job.started.catch(() => {
+    });
+    return job;
+  }
+  async function terminate(job) {
+    if (!job || job.done) return;
+    job.child.kill("SIGTERM");
+    const timer = setTimeout(() => {
+      if (!job.done) job.child.kill("SIGKILL");
+    }, killTimeoutMs);
+    try {
+      await job.closed;
+    } finally {
+      clearTimeout(timer);
+    }
+  }
+  async function cleanup(session) {
+    if (!session) return;
+    session.cancelled = true;
+    clearTimeout(session.timer);
+    await Promise.all([terminate(session.recorder), terminate(session.transcriber)]);
+    if (session.dir) await files.rm(session.dir, { recursive: true, force: true });
+    if (active === session) active = null;
+  }
+  async function start() {
+    if (active) throw new Error("Dictation is already active.");
+    const session = { chunks: [], bytes: 0, cancelled: false, stopping: false };
+    active = session;
+    try {
+      const whisper = env.PICO_WHISPER_BIN ? await executable(env.PICO_WHISPER_BIN) : await executable(join(env.XDG_CACHE_HOME || join(homedir(), ".cache"), "pico/whisper/whisper-cli")) || await executable("whisper-cli");
+      if (!whisper) throw new Error("Install whisper.cpp and put whisper-cli on PATH, or set PICO_WHISPER_BIN.");
+      try {
+        await files.access(model, constants.R_OK);
+      } catch {
+        throw new Error(`Whisper model not found or unreadable: ${model}. Install a whisper.cpp GGML model and set PICO_WHISPER_MODEL (no models are downloaded automatically).`);
+      }
+      const pw = await executable("pw-record");
+      const recorder = pw || await executable("parec");
+      if (!recorder) throw new Error("Install PipeWire (pw-record) or PulseAudio utilities (parec) for microphone recording.");
+      if (session.cancelled) return;
+      session.whisper = whisper;
+      session.dir = await files.mkdtemp(join(tempRoot, "pico-dictation-"));
+      if (session.cancelled) {
+        await cleanup(session);
+        return;
+      }
+      const args = pw ? ["--raw", "--format", "s16", "--rate", "16000", "--channels", "1"] : ["--raw", "--format=s16le", "--rate=16000", "--channels=1"];
+      if (env.PICO_DICTATION_SOURCE) args.push(pw ? "--target" : "--device", env.PICO_DICTATION_SOURCE);
+      if (pw) args.push("-");
+      const job = session.recorder = launch(recorder, args);
+      let lastLevel = 0;
+      job.child.stdout.on("data", (chunk) => {
+        if (session.cancelled || session.stopping) return;
+        const remaining = Math.floor(maxRecordingMs * 32) - session.bytes;
+        const data = Buffer.from(chunk.subarray(0, Math.max(0, remaining)));
+        session.chunks.push(data);
+        session.bytes += data.length;
+        if (Date.now() - lastLevel >= 50) {
+          let sum = 0;
+          for (let i = 0; i + 1 < data.length; i += 2) sum += (data.readInt16LE(i) / 32768) ** 2;
+          send({ status: "level", level: data.length >= 2 ? Math.sqrt(sum / Math.floor(data.length / 2)) : 0 });
+          lastLevel = Date.now();
+        }
+        if (session.bytes >= Math.floor(maxRecordingMs * 32)) void limit();
+      });
+      const limit = async () => {
+        if (session.cancelled || session.stopping) return;
+        session.stopping = true;
+        send({ status: "error", message: "Dictation reached the 120-second recording limit. Please record a shorter passage." });
+        await cleanup(session);
+      };
+      await job.started;
+      job.closed.then(async (code) => {
+        if (session.cancelled || session.stopping) return;
+        send({ status: "error", message: `Microphone recording stopped unexpectedly (${code ?? job.error?.message ?? "unknown error"}). Check your audio source and permissions.${job.stderr ? ` ${job.stderr.trim()}` : ""}` });
+        await cleanup(session);
+      });
+      session.timer = setTimeout(() => {
+        void limit();
+      }, maxRecordingMs);
+    } catch (error) {
+      await cleanup(session);
+      throw error;
+    }
+  }
+  async function stop() {
+    const session = active;
+    if (!session || !session.recorder || session.stopping) throw new Error("No active dictation recording.");
+    session.stopping = true;
+    clearTimeout(session.timer);
+    try {
+      await terminate(session.recorder);
+      if (session.cancelled) throw new Error("Dictation cancelled.");
+      const pcm = Buffer.concat(session.chunks);
+      const audio = join(session.dir, "audio.wav");
+      const prefix = join(session.dir, "transcript");
+      const even = pcm.subarray(0, pcm.length - pcm.length % 2);
+      await files.writeFile(audio, Buffer.concat([wavHeader(even.length), even]), { mode: 384 });
+      if (session.cancelled) throw new Error("Dictation cancelled.");
+      const job = session.transcriber = launch(session.whisper, ["-m", model, "-f", audio, "-otxt", "-of", prefix, "-l", env.PICO_WHISPER_LANGUAGE || "en", "-nt"]);
+      const code = await job.closed;
+      if (session.cancelled) throw new Error("Dictation cancelled.");
+      if (job.error || code !== 0) throw new Error(`Whisper transcription failed: ${job.error?.message || job.stderr.trim() || `exit ${code}`}`);
+      return (await files.readFile(`${prefix}.txt`, "utf8")).trim();
+    } finally {
+      await cleanup(session);
+    }
+  }
+  async function handle(command) {
+    if (disposed) return;
+    const id = command?.id;
+    try {
+      if (id == null) throw new Error("Command requires an id.");
+      if (command.op === "start") {
+        await start();
+        send({ id });
+      } else if (command.op === "stop") send({ id, text: await stop() });
+      else if (command.op === "cancel") {
+        await cleanup(active);
+        send({ id });
+      } else throw new Error("Unknown dictation command.");
+    } catch (error) {
+      send({ id, error: error.message });
+    }
+  }
+  async function dispose() {
+    disposed = true;
+    await cleanup(active);
+    await Promise.all([...jobs].map(terminate));
+  }
+  return { handle, dispose };
+}
+function runLinuxDictation({ input = process.stdin, output = process.stdout, signals = process, ...options } = {}) {
+  const emit = (message) => output.write(`${JSON.stringify(message)}
+`);
+  const helper = createLinuxDictation({ ...options, emit });
+  const lines = createInterface({ input });
+  let closing = false;
+  const close = async () => {
+    if (closing) return;
+    closing = true;
+    lines.close();
+    signals.removeListener("SIGTERM", close);
+    signals.removeListener("SIGINT", close);
+    await helper.dispose();
+  };
+  lines.on("line", (line) => {
+    if (line.length > 65536) return emit({ status: "error", message: "Dictation command is too large." });
+    try {
+      void helper.handle(JSON.parse(line));
+    } catch {
+      emit({ status: "error", message: "Invalid dictation command JSON." });
+    }
+  });
+  lines.on("close", close);
+  input.on("error", close);
+  output.on("error", close);
+  signals.on("SIGTERM", close);
+  signals.on("SIGINT", close);
+  emit({ status: "ready" });
+  return { ...helper, dispose: close };
+}
+if (process.argv[1] && resolve(process.argv[1]) === fileURLToPath(import.meta.url)) runLinuxDictation();
+export {
+  createLinuxDictation,
+  findExecutable,
+  runLinuxDictation,
+  wavHeader
+};
+//# sourceMappingURL=data:application/json;base64,{
  "version": 3,
  "sources": ["../helper/linux-dictate.js"],
  "sourcesContent": ["#!/usr/bin/env node\nimport { spawn as nodeSpawn } from 'node:child_process'\nimport * as fs from 'node:fs/promises'\nimport { constants } from 'node:fs'\nimport { homedir, tmpdir } from 'node:os'\nimport { delimiter, join, resolve } from 'node:path'\nimport { fileURLToPath } from 'node:url'\nimport { createInterface } from 'node:readline'\n\nexport function wavHeader(bytes) {\n  const header = Buffer.alloc(44)\n  header.write('RIFF'); header.writeUInt32LE(bytes + 36, 4); header.write('WAVEfmt ', 8)\n  header.writeUInt32LE(16, 16); header.writeUInt16LE(1, 20); header.writeUInt16LE(1, 22)\n  header.writeUInt32LE(16000, 24); header.writeUInt32LE(32000, 28)\n  header.writeUInt16LE(2, 32); header.writeUInt16LE(16, 34)\n  header.write('data', 36); header.writeUInt32LE(bytes, 40)\n  return header\n}\n\nexport async function findExecutable(name, env = process.env) {\n  const paths = name.includes('/') ? [name] : (env.PATH || '').split(delimiter).map(dir => join(dir, name))\n  for (const path of paths) {\n    try { await fs.access(path, constants.X_OK); return path } catch {}\n  }\n  return null\n}\n\nexport function createLinuxDictation({ emit = () => {}, spawn = nodeSpawn, env = process.env,\n  executable = name => findExecutable(name, env), files = fs, tempRoot = tmpdir(),\n  maxRecordingMs = 120000, killTimeoutMs = 1000 } = {}) {\n  const model = env.PICO_WHISPER_MODEL || join(env.XDG_CACHE_HOME || join(homedir(), '.cache'), 'pico/whisper/ggml-base.en.bin')\n  let active = null\n  let disposed = false\n  const jobs = new Set()\n  const send = message => { if (!disposed) emit(message) }\n\n  function launch(binary, args) {\n    const child = spawn(binary, args, { stdio: ['ignore', 'pipe', 'pipe'] })\n    const job = { child, error: null, stderr: '', done: false }\n    jobs.add(job)\n    child.stderr?.on('data', chunk => { job.stderr = (job.stderr + chunk.toString()).slice(-4096) })\n    job.closed = new Promise(resolve => {\n      child.once('error', error => { job.error = error; finish(null) })\n      child.once('close', code => finish(code))\n      function finish(code) {\n        if (job.done) return\n        job.done = true; jobs.delete(job); resolve(code)\n      }\n    })\n    job.started = new Promise((resolve, reject) => {\n      child.once('spawn', resolve); child.once('error', reject)\n    })\n    // Transcription may be cancelled before anyone awaits startup.\n    job.started.catch(() => {})\n    return job\n  }\n\n  async function terminate(job) {\n    if (!job || job.done) return\n    job.child.kill('SIGTERM')\n    const timer = setTimeout(() => { if (!job.done) job.child.kill('SIGKILL') }, killTimeoutMs)\n    try { await job.closed } finally { clearTimeout(timer) }\n  }\n\n  async function cleanup(session) {\n    if (!session) return\n    session.cancelled = true\n    clearTimeout(session.timer)\n    await Promise.all([terminate(session.recorder), terminate(session.transcriber)])\n    if (session.dir) await files.rm(session.dir, { recursive: true, force: true })\n    if (active === session) active = null\n  }\n\n  async function start() {\n    if (active) throw new Error('Dictation is already active.')\n    const session = { chunks: [], bytes: 0, cancelled: false, stopping: false }\n    active = session\n    try {\n      const whisper = env.PICO_WHISPER_BIN\n        ? await executable(env.PICO_WHISPER_BIN)\n        : await executable(join(env.XDG_CACHE_HOME || join(homedir(), '.cache'), 'pico/whisper/whisper-cli')) || await executable('whisper-cli')\n      if (!whisper) throw new Error('Install whisper.cpp and put whisper-cli on PATH, or set PICO_WHISPER_BIN.')\n      try { await files.access(model, constants.R_OK) } catch {\n        throw new Error(`Whisper model not found or unreadable: ${model}. Install a whisper.cpp GGML model and set PICO_WHISPER_MODEL (no models are downloaded automatically).`)\n      }\n      const pw = await executable('pw-record')\n      const recorder = pw || await executable('parec')\n      if (!recorder) throw new Error('Install PipeWire (pw-record) or PulseAudio utilities (parec) for microphone recording.')\n      if (session.cancelled) return\n      session.whisper = whisper\n      session.dir = await files.mkdtemp(join(tempRoot, 'pico-dictation-'))\n      if (session.cancelled) { await cleanup(session); return }\n      const args = pw ? ['--raw', '--format', 's16', '--rate', '16000', '--channels', '1'] : ['--raw', '--format=s16le', '--rate=16000', '--channels=1']\n      if (env.PICO_DICTATION_SOURCE) args.push(pw ? '--target' : '--device', env.PICO_DICTATION_SOURCE)\n      if (pw) args.push('-')\n      const job = session.recorder = launch(recorder, args)\n      let lastLevel = 0\n      job.child.stdout.on('data', chunk => {\n        if (session.cancelled || session.stopping) return\n        const remaining = Math.floor(maxRecordingMs * 32) - session.bytes\n        const data = Buffer.from(chunk.subarray(0, Math.max(0, remaining)))\n        session.chunks.push(data); session.bytes += data.length\n        if (Date.now() - lastLevel >= 50) {\n          let sum = 0\n          for (let i = 0; i + 1 < data.length; i += 2) sum += (data.readInt16LE(i) / 32768) ** 2\n          send({ status: 'level', level: data.length >= 2 ? Math.sqrt(sum / Math.floor(data.length / 2)) : 0 })\n          lastLevel = Date.now()\n        }\n        if (session.bytes >= Math.floor(maxRecordingMs * 32)) void limit()\n      })\n      const limit = async () => {\n        if (session.cancelled || session.stopping) return\n        session.stopping = true\n        send({ status: 'error', message: 'Dictation reached the 120-second recording limit. Please record a shorter passage.' })\n        await cleanup(session)\n      }\n      await job.started\n      job.closed.then(async code => {\n        if (session.cancelled || session.stopping) return\n        send({ status: 'error', message: `Microphone recording stopped unexpectedly (${code ?? job.error?.message ?? 'unknown error'}). Check your audio source and permissions.${job.stderr ? ` ${job.stderr.trim()}` : ''}` })\n        await cleanup(session)\n      })\n      session.timer = setTimeout(() => { void limit() }, maxRecordingMs)\n    } catch (error) { await cleanup(session); throw error }\n  }\n\n  async function stop() {\n    const session = active\n    if (!session || !session.recorder || session.stopping) throw new Error('No active dictation recording.')\n    session.stopping = true\n    clearTimeout(session.timer)\n    try {\n      await terminate(session.recorder)\n      if (session.cancelled) throw new Error('Dictation cancelled.')\n      const pcm = Buffer.concat(session.chunks)\n      const audio = join(session.dir, 'audio.wav')\n      const prefix = join(session.dir, 'transcript')\n      const even = pcm.subarray(0, pcm.length - pcm.length % 2)\n      await files.writeFile(audio, Buffer.concat([wavHeader(even.length), even]), { mode: 0o600 })\n      if (session.cancelled) throw new Error('Dictation cancelled.')\n      const job = session.transcriber = launch(session.whisper, ['-m', model, '-f', audio, '-otxt', '-of', prefix, '-l', env.PICO_WHISPER_LANGUAGE || 'en', '-nt'])\n      const code = await job.closed\n      if (session.cancelled) throw new Error('Dictation cancelled.')\n      if (job.error || code !== 0) throw new Error(`Whisper transcription failed: ${job.error?.message || job.stderr.trim() || `exit ${code}`}`)\n      return (await files.readFile(`${prefix}.txt`, 'utf8')).trim()\n    } finally { await cleanup(session) }\n  }\n\n  async function handle(command) {\n    if (disposed) return\n    const id = command?.id\n    try {\n      if (id == null) throw new Error('Command requires an id.')\n      if (command.op === 'start') { await start(); send({ id }) }\n      else if (command.op === 'stop') send({ id, text: await stop() })\n      else if (command.op === 'cancel') { await cleanup(active); send({ id }) }\n      else throw new Error('Unknown dictation command.')\n    } catch (error) { send({ id, error: error.message }) }\n  }\n\n  async function dispose() {\n    disposed = true\n    await cleanup(active)\n    await Promise.all([...jobs].map(terminate))\n  }\n  return { handle, dispose }\n}\n\nexport function runLinuxDictation({ input = process.stdin, output = process.stdout, signals = process, ...options } = {}) {\n  const emit = message => output.write(`${JSON.stringify(message)}\\n`)\n  const helper = createLinuxDictation({ ...options, emit })\n  const lines = createInterface({ input })\n  let closing = false\n  const close = async () => {\n    if (closing) return\n    closing = true\n    lines.close()\n    signals.removeListener('SIGTERM', close); signals.removeListener('SIGINT', close)\n    await helper.dispose()\n  }\n  lines.on('line', line => {\n    if (line.length > 65536) return emit({ status: 'error', message: 'Dictation command is too large.' })\n    try { void helper.handle(JSON.parse(line)) } catch { emit({ status: 'error', message: 'Invalid dictation command JSON.' }) }\n  })\n  lines.on('close', close)\n  input.on('error', close)\n  output.on('error', close)\n  signals.on('SIGTERM', close); signals.on('SIGINT', close)\n  emit({ status: 'ready' })\n  return { ...helper, dispose: close }\n}\n\nif (process.argv[1] && resolve(process.argv[1]) === fileURLToPath(import.meta.url)) runLinuxDictation()\n"],
  "mappings": "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",
  "names": ["resolve"]
}
