@jdi-code/claude-code 1.0.3 → 1.2.0

package/dist/{chunk-vqr58rfh.js → chunk-mky388t4.js}

@@ -1,22 +1,18 @@
 // @bun
 import {
-  require_compiler_runtime
-} from "./chunk-z72st5c8.js";
+  init_config1 as init_config,
+  saveCurrentProjectConfig
+} from "./chunk-zhtrjznv.js";
 import {
   require_jsx_dev_runtime,
   require_react
 } from "./chunk-g338npwr.js";
-import {
-  init_config1 as init_config,
-  saveCurrentProjectConfig
-} from "./chunk-53nbpp47.js";
 import {
   __toESM
 } from "./chunk-qp2qdcda.js";
 
 // src/context/stats.tsx
 init_config();
-var import_compiler_runtime = __toESM(require_compiler_runtime(), 1);
 var import_react = __toESM(require_react(), 1);
 var jsx_dev_runtime = __toESM(require_jsx_dev_runtime(), 1);
 function percentile(sorted, p) {
@@ -43,13 +39,7 @@ function createStatsStore() {
     observe(name, value) {
       let h = histograms.get(name);
       if (!h) {
-        h = {
-          reservoir: [],
-          count: 0,
-          sum: 0,
-          min: value,
-          max: value
-        };
+        h = { reservoir: [], count: 0, sum: 0, min: value, max: value };
         histograms.set(name, h);
       }
       h.count++;
@@ -100,61 +90,31 @@ function createStatsStore() {
   };
 }
 var StatsContext = import_react.createContext(null);
-function StatsProvider(t0) {
-  const $ = import_compiler_runtime.c(7);
-  const {
-    store: externalStore,
-    children
-  } = t0;
-  let t1;
-  if ($[0] === Symbol.for("react.memo_cache_sentinel")) {
-    t1 = createStatsStore();
-    $[0] = t1;
-  } else {
-    t1 = $[0];
-  }
-  const internalStore = t1;
+function StatsProvider({
+  store: externalStore,
+  children
+}) {
+  const internalStore = import_react.useMemo(() => createStatsStore(), []);
   const store = externalStore ?? internalStore;
-  let t2;
-  let t3;
-  if ($[1] !== store) {
-    t2 = () => {
-      const flush = () => {
-        const metrics = store.getAll();
-        if (Object.keys(metrics).length > 0) {
-          saveCurrentProjectConfig((current) => ({
-            ...current,
-            lastSessionMetrics: metrics
-          }));
-        }
-      };
-      process.on("exit", flush);
-      return () => {
-        process.off("exit", flush);
-      };
+  import_react.useEffect(() => {
+    const flush = () => {
+      const metrics = store.getAll();
+      if (Object.keys(metrics).length > 0) {
+        saveCurrentProjectConfig((current) => ({
+          ...current,
+          lastSessionMetrics: metrics
+        }));
+      }
     };
-    t3 = [store];
-    $[1] = store;
-    $[2] = t2;
-    $[3] = t3;
-  } else {
-    t2 = $[2];
-    t3 = $[3];
-  }
-  import_react.useEffect(t2, t3);
-  let t4;
-  if ($[4] !== children || $[5] !== store) {
-    t4 = /* @__PURE__ */ jsx_dev_runtime.jsxDEV(StatsContext.Provider, {
-      value: store,
-      children
-    }, undefined, false, undefined, this);
-    $[4] = children;
-    $[5] = store;
-    $[6] = t4;
-  } else {
-    t4 = $[6];
-  }
-  return t4;
+    process.on("exit", flush);
+    return () => {
+      process.off("exit", flush);
+    };
+  }, [store]);
+  return /* @__PURE__ */ jsx_dev_runtime.jsxDEV(StatsContext.Provider, {
+    value: store,
+    children
+  }, undefined, false, undefined, this);
 }
 
 export { createStatsStore, StatsProvider };

package/dist/chunk-mn61mk4v.js

@@ -0,0 +1,351 @@
+// @bun
+import {
+  getPlatform,
+  init_platform
+} from "./chunk-gx8016vp.js";
+import {
+  init_log,
+  logError
+} from "./chunk-y3r7v9pq.js";
+import"./chunk-8tnsngw2.js";
+import {
+  init_debug,
+  logForDebugging
+} from "./chunk-404qm8xt.js";
+import"./chunk-fbv4apne.js";
+import {
+  init_envUtils,
+  isEnvTruthy,
+  isRunningOnHomespace
+} from "./chunk-jaaxk89e.js";
+import"./chunk-h4b85amj.js";
+import"./chunk-07069jq1.js";
+import"./chunk-vf612n57.js";
+import"./chunk-d4mdda98.js";
+import"./chunk-4g3v8y12.js";
+import"./chunk-7739pg2c.js";
+import {
+  __esm,
+  __require
+} from "./chunk-qp2qdcda.js";
+
+// src/services/voice.ts
+import { spawn, spawnSync } from "child_process";
+import { readFile } from "fs/promises";
+function loadAudioNapi() {
+  audioNapiPromise ??= (async () => {
+    const t0 = Date.now();
+    const mod = await import("./chunk-yzx3mhfd.js");
+    mod.isNativeAudioAvailable();
+    audioNapi = mod;
+    logForDebugging(`[voice] audio-capture-napi loaded in ${Date.now() - t0}ms`);
+    return mod;
+  })();
+  return audioNapiPromise;
+}
+function hasCommand(cmd) {
+  const result = spawnSync(cmd, ["--version"], {
+    stdio: "ignore",
+    timeout: 3000
+  });
+  return result.error === undefined;
+}
+function probeArecord() {
+  arecordProbe ??= new Promise((resolve) => {
+    const child = spawn("arecord", [
+      "-f",
+      "S16_LE",
+      "-r",
+      String(RECORDING_SAMPLE_RATE),
+      "-c",
+      String(RECORDING_CHANNELS),
+      "-t",
+      "raw",
+      "/dev/null"
+    ], { stdio: ["ignore", "ignore", "pipe"] });
+    let stderr = "";
+    child.stderr?.on("data", (chunk) => {
+      stderr += chunk.toString();
+    });
+    const timer = setTimeout((c, r) => {
+      c.kill("SIGTERM");
+      r({ ok: true, stderr: "" });
+    }, 150, child, resolve);
+    child.once("close", (code) => {
+      clearTimeout(timer);
+      resolve({ ok: code === 0, stderr: stderr.trim() });
+    });
+    child.once("error", () => {
+      clearTimeout(timer);
+      resolve({ ok: false, stderr: "arecord: command not found" });
+    });
+  });
+  return arecordProbe;
+}
+function _resetArecordProbeForTesting() {
+  arecordProbe = null;
+}
+function linuxHasAlsaCards() {
+  linuxAlsaCardsMemo ??= readFile("/proc/asound/cards", "utf8").then((cards) => {
+    const c = cards.trim();
+    return c !== "" && !c.includes("no soundcards");
+  }, () => false);
+  return linuxAlsaCardsMemo;
+}
+function _resetAlsaCardsForTesting() {
+  linuxAlsaCardsMemo = null;
+}
+function detectPackageManager() {
+  if (process.platform === "darwin") {
+    if (hasCommand("brew")) {
+      return {
+        cmd: "brew",
+        args: ["install", "sox"],
+        displayCommand: "brew install sox"
+      };
+    }
+    return null;
+  }
+  if (process.platform === "linux") {
+    if (hasCommand("apt-get")) {
+      return {
+        cmd: "sudo",
+        args: ["apt-get", "install", "-y", "sox"],
+        displayCommand: "sudo apt-get install sox"
+      };
+    }
+    if (hasCommand("dnf")) {
+      return {
+        cmd: "sudo",
+        args: ["dnf", "install", "-y", "sox"],
+        displayCommand: "sudo dnf install sox"
+      };
+    }
+    if (hasCommand("pacman")) {
+      return {
+        cmd: "sudo",
+        args: ["pacman", "-S", "--noconfirm", "sox"],
+        displayCommand: "sudo pacman -S sox"
+      };
+    }
+  }
+  return null;
+}
+async function checkVoiceDependencies() {
+  const napi = await loadAudioNapi();
+  if (napi.isNativeAudioAvailable()) {
+    return { available: true, missing: [], installCommand: null };
+  }
+  if (process.platform === "win32") {
+    return {
+      available: false,
+      missing: ["Voice mode requires the native audio module (not loaded)"],
+      installCommand: null
+    };
+  }
+  if (process.platform === "linux" && hasCommand("arecord")) {
+    return { available: true, missing: [], installCommand: null };
+  }
+  const missing = [];
+  if (!hasCommand("rec")) {
+    missing.push("sox (rec command)");
+  }
+  const pm = missing.length > 0 ? detectPackageManager() : null;
+  return {
+    available: missing.length === 0,
+    missing,
+    installCommand: pm?.displayCommand ?? null
+  };
+}
+async function requestMicrophonePermission() {
+  const napi = await loadAudioNapi();
+  if (!napi.isNativeAudioAvailable()) {
+    return true;
+  }
+  const started = await startRecording((_chunk) => {}, () => {}, { silenceDetection: false });
+  if (started) {
+    stopRecording();
+    return true;
+  }
+  return false;
+}
+async function checkRecordingAvailability() {
+  if (isRunningOnHomespace() || isEnvTruthy(process.env.CLAUDE_CODE_REMOTE)) {
+    return {
+      available: false,
+      reason: `Voice mode requires microphone access, but no audio device is available in this environment.
+
+To use voice mode, run Claude Code locally instead.`
+    };
+  }
+  const napi = await loadAudioNapi();
+  if (napi.isNativeAudioAvailable()) {
+    return { available: true, reason: null };
+  }
+  if (process.platform === "win32") {
+    return {
+      available: false,
+      reason: "Voice recording requires the native audio module, which could not be loaded."
+    };
+  }
+  const wslNoAudioReason = `Voice mode could not access an audio device in WSL.
+
+WSL2 with WSLg (Windows 11) provides audio via PulseAudio \u2014 if you are on Windows 10 or WSL1, run Claude Code in native Windows instead.`;
+  if (process.platform === "linux" && hasCommand("arecord")) {
+    const probe = await probeArecord();
+    if (probe.ok) {
+      return { available: true, reason: null };
+    }
+    if (getPlatform() === "wsl") {
+      return { available: false, reason: wslNoAudioReason };
+    }
+    logForDebugging(`[voice] arecord probe failed: ${probe.stderr}`);
+  }
+  if (!hasCommand("rec")) {
+    if (getPlatform() === "wsl") {
+      return { available: false, reason: wslNoAudioReason };
+    }
+    const pm = detectPackageManager();
+    return {
+      available: false,
+      reason: pm ? `Voice mode requires SoX for audio recording. Install it with: ${pm.displayCommand}` : `Voice mode requires SoX for audio recording. Install SoX manually:
+  macOS: brew install sox
+  Ubuntu/Debian: sudo apt-get install sox
+  Fedora: sudo dnf install sox`
+    };
+  }
+  return { available: true, reason: null };
+}
+async function startRecording(onData, onEnd, options) {
+  logForDebugging(`[voice] startRecording called, platform=${process.platform}`);
+  const napi = await loadAudioNapi();
+  const nativeAvailable = napi.isNativeAudioAvailable() && (process.platform !== "linux" || await linuxHasAlsaCards());
+  const useSilenceDetection = options?.silenceDetection !== false;
+  if (nativeAvailable) {
+    if (nativeRecordingActive || napi.isNativeRecordingActive()) {
+      napi.stopNativeRecording();
+      nativeRecordingActive = false;
+    }
+    const started = napi.startNativeRecording((data) => {
+      onData(data);
+    }, () => {
+      if (useSilenceDetection) {
+        nativeRecordingActive = false;
+        onEnd();
+      }
+    });
+    if (started) {
+      nativeRecordingActive = true;
+      return true;
+    }
+  }
+  if (process.platform === "win32") {
+    logForDebugging("[voice] Windows native recording unavailable, no fallback");
+    return false;
+  }
+  if (process.platform === "linux" && hasCommand("arecord") && (await probeArecord()).ok) {
+    return startArecordRecording(onData, onEnd);
+  }
+  return startSoxRecording(onData, onEnd, options);
+}
+function startSoxRecording(onData, onEnd, options) {
+  const useSilenceDetection = options?.silenceDetection !== false;
+  const args = [
+    "-q",
+    "--buffer",
+    "1024",
+    "-t",
+    "raw",
+    "-r",
+    String(RECORDING_SAMPLE_RATE),
+    "-e",
+    "signed",
+    "-b",
+    "16",
+    "-c",
+    String(RECORDING_CHANNELS),
+    "-"
+  ];
+  if (useSilenceDetection) {
+    args.push("silence", "1", "0.1", SILENCE_THRESHOLD, "1", SILENCE_DURATION_SECS, SILENCE_THRESHOLD);
+  }
+  const child = spawn("rec", args, {
+    stdio: ["pipe", "pipe", "pipe"]
+  });
+  activeRecorder = child;
+  child.stdout?.on("data", (chunk) => {
+    onData(chunk);
+  });
+  child.stderr?.on("data", () => {});
+  child.on("close", () => {
+    activeRecorder = null;
+    onEnd();
+  });
+  child.on("error", (err) => {
+    logError(err);
+    activeRecorder = null;
+    onEnd();
+  });
+  return true;
+}
+function startArecordRecording(onData, onEnd) {
+  const args = [
+    "-f",
+    "S16_LE",
+    "-r",
+    String(RECORDING_SAMPLE_RATE),
+    "-c",
+    String(RECORDING_CHANNELS),
+    "-t",
+    "raw",
+    "-q",
+    "-"
+  ];
+  const child = spawn("arecord", args, {
+    stdio: ["pipe", "pipe", "pipe"]
+  });
+  activeRecorder = child;
+  child.stdout?.on("data", (chunk) => {
+    onData(chunk);
+  });
+  child.stderr?.on("data", () => {});
+  child.on("close", () => {
+    activeRecorder = null;
+    onEnd();
+  });
+  child.on("error", (err) => {
+    logError(err);
+    activeRecorder = null;
+    onEnd();
+  });
+  return true;
+}
+function stopRecording() {
+  if (nativeRecordingActive && audioNapi) {
+    audioNapi.stopNativeRecording();
+    nativeRecordingActive = false;
+    return;
+  }
+  if (activeRecorder) {
+    activeRecorder.kill("SIGTERM");
+    activeRecorder = null;
+  }
+}
+var audioNapi = null, audioNapiPromise = null, RECORDING_SAMPLE_RATE = 16000, RECORDING_CHANNELS = 1, SILENCE_DURATION_SECS = "2.0", SILENCE_THRESHOLD = "3%", arecordProbe = null, linuxAlsaCardsMemo = null, activeRecorder = null, nativeRecordingActive = false;
+var init_voice = __esm(() => {
+  init_debug();
+  init_envUtils();
+  init_log();
+  init_platform();
+});
+init_voice();
+
+export {
+  stopRecording,
+  startRecording,
+  requestMicrophonePermission,
+  checkVoiceDependencies,
+  checkRecordingAvailability,
+  _resetArecordProbeForTesting,
+  _resetAlsaCardsForTesting
+};