@redscope-ai/redscope 1.0.0

package/dist/chunk-zbxtzycc.js

@@ -0,0 +1,274 @@
+// @bun
+import {
+  getRecentActivity,
+  init_logoV2Utils
+} from "./chunk-zkch6trx.js";
+import"./chunk-td2gsz7s.js";
+import"./chunk-gmdy2w3z.js";
+import"./chunk-q0e485mg.js";
+import"./chunk-2kcgxnvp.js";
+import"./chunk-14p6wvsq.js";
+import"./chunk-6s0q1s5r.js";
+import"./chunk-3w9sye8h.js";
+import"./chunk-nzxfj0gq.js";
+import"./chunk-vr0n9pv9.js";
+import"./chunk-9a9g5hbj.js";
+import"./chunk-ptxteaeh.js";
+import"./chunk-w4p5t920.js";
+import"./chunk-rgyzsbs3.js";
+import"./chunk-q3b4n194.js";
+import {
+  createTask,
+  getTask,
+  getTasksDir,
+  init_tasks,
+  listTasks,
+  updateTask
+} from "./chunk-kywtr3jg.js";
+import"./chunk-eewg66y1.js";
+import"./chunk-71sdcaq6.js";
+import"./chunk-9hn8e6h1.js";
+import"./chunk-7qey87th.js";
+import"./chunk-zw62m6n3.js";
+import"./chunk-1w20m7gw.js";
+import"./chunk-zzf074w3.js";
+import"./chunk-rpmntgyh.js";
+import"./chunk-24kv69g3.js";
+import"./chunk-hzxzvzw8.js";
+import"./chunk-30wnahyg.js";
+import"./chunk-ztmb7geg.js";
+import"./chunk-tbdkekz3.js";
+import"./chunk-65zbgg1n.js";
+import"./chunk-4spgkgr3.js";
+import"./chunk-60fkafk2.js";
+import"./chunk-50m3a23z.js";
+import"./chunk-6hygvrhn.js";
+import"./chunk-7tfdhkpy.js";
+import"./chunk-8gv2pjby.js";
+import"./chunk-g06pm4n9.js";
+import"./chunk-2p369q9z.js";
+import"./chunk-z0jgeax8.js";
+import"./chunk-w68wc625.js";
+import"./chunk-6hr7742d.js";
+import"./chunk-xyg1sk2w.js";
+import"./chunk-935nrvdb.js";
+import"./chunk-8zz4z1q3.js";
+import"./chunk-fncpkzs5.js";
+import"./chunk-hqxp6b72.js";
+import"./chunk-m2c3bjv1.js";
+import"./chunk-jhtccjc9.js";
+import"./chunk-7nvday0n.js";
+import"./chunk-vxbjzggp.js";
+import"./chunk-yc1stfve.js";
+import"./chunk-8yvsnrkr.js";
+import"./chunk-5mmhfbxb.js";
+import"./chunk-eemjb825.js";
+import"./chunk-ga1jkyqy.js";
+import"./chunk-y1q7rt9n.js";
+import"./chunk-8kct9arg.js";
+import"./chunk-k7hexw3v.js";
+import"./chunk-trqrj23e.js";
+import"./chunk-za3k6h2h.js";
+import"./chunk-8kf8h7xf.js";
+import"./chunk-bgan4cpf.js";
+import"./chunk-jmv7k0jn.js";
+import"./chunk-hjxqmtg5.js";
+import"./chunk-bzyzrq0k.js";
+import"./chunk-vwenx8ke.js";
+import"./chunk-q2h79ncs.js";
+import"./chunk-v4ypszbb.js";
+import"./chunk-qfsn720k.js";
+import"./chunk-7qx3xhv3.js";
+import"./chunk-j9475b46.js";
+import"./chunk-fdwabr8p.js";
+import"./chunk-e4dsy4g1.js";
+import"./chunk-326zehp8.js";
+import"./chunk-kc67kt75.js";
+import"./chunk-40t1d75v.js";
+import"./chunk-dbts5q5p.js";
+import"./chunk-e3abfxpy.js";
+import"./chunk-q44zc68f.js";
+import"./chunk-fejeqe61.js";
+import"./chunk-q1vrhh0q.js";
+import"./chunk-hn4w9pkj.js";
+import"./chunk-2g0ytd9d.js";
+import"./chunk-de0qnnf7.js";
+import"./chunk-j1mep9ck.js";
+import"./chunk-6x35ffpx.js";
+import"./chunk-1zbwhcbt.js";
+import"./chunk-92bjkrf2.js";
+import"./chunk-10k5jfc5.js";
+import"./chunk-n9g24mwe.js";
+import"./chunk-e3j7m7k2.js";
+import"./chunk-hzmzwte2.js";
+import"./chunk-pdvg91cg.js";
+import"./chunk-c696122m.js";
+import"./chunk-xbj5keyy.js";
+import"./chunk-c1yc761e.js";
+import"./chunk-c5g9shkw.js";
+import"./chunk-aeysytks.js";
+import"./chunk-s3hafnk3.js";
+import"./chunk-kb3758f7.js";
+import"./chunk-9h9k5vz3.js";
+import"./chunk-xmpgmeb8.js";
+import"./chunk-2kz09j2s.js";
+import"./chunk-c0k7b0jw.js";
+import"./chunk-pecy49yr.js";
+import"./chunk-azbab59e.js";
+import"./chunk-3nk9q8dr.js";
+import {
+  __require
+} from "./chunk-hhsxm2yr.js";
+
+// src/cli/handlers/ant.ts
+init_tasks();
+init_logoV2Utils();
+var DEFAULT_LIST = "default";
+async function taskCreateHandler(subject, opts) {
+  const listId = opts.list || DEFAULT_LIST;
+  const id = await createTask(listId, {
+    subject,
+    description: opts.description || "",
+    status: "pending",
+    blocks: [],
+    blockedBy: []
+  });
+  console.log(`Created task ${id}: ${subject}`);
+}
+async function taskListHandler(opts) {
+  const listId = opts.list || DEFAULT_LIST;
+  let tasks = await listTasks(listId);
+  if (opts.pending) {
+    tasks = tasks.filter((t) => t.status === "pending");
+  }
+  if (opts.json) {
+    console.log(JSON.stringify(tasks, null, 2));
+    return;
+  }
+  if (tasks.length === 0) {
+    console.log("No tasks found.");
+    return;
+  }
+  for (const t of tasks) {
+    console.log(`  [${t.status}] ${t.id}: ${t.subject}`);
+    if (t.description)
+      console.log(`    ${t.description}`);
+    if (t.owner)
+      console.log(`    owner: ${t.owner}`);
+  }
+}
+async function taskGetHandler(id, opts) {
+  const listId = opts.list || DEFAULT_LIST;
+  const task = await getTask(listId, id);
+  if (!task) {
+    console.error(`Task not found: ${id}`);
+    process.exitCode = 1;
+    return;
+  }
+  console.log(JSON.stringify(task, null, 2));
+}
+async function taskUpdateHandler(id, opts) {
+  const listId = opts.list || DEFAULT_LIST;
+  const updates = {};
+  if (opts.status)
+    updates.status = opts.status;
+  if (opts.subject)
+    updates.subject = opts.subject;
+  if (opts.description)
+    updates.description = opts.description;
+  if (opts.owner)
+    updates.owner = opts.owner;
+  if (opts.clearOwner)
+    updates.owner = undefined;
+  const task = await updateTask(listId, id, updates);
+  if (!task) {
+    console.error(`Task not found: ${id}`);
+    process.exitCode = 1;
+    return;
+  }
+  console.log(`Updated task ${id}: [${task.status}] ${task.subject}`);
+}
+async function taskDirHandler(opts) {
+  const listId = opts.list || DEFAULT_LIST;
+  console.log(getTasksDir(listId));
+}
+async function logHandler(logId) {
+  const logs = await getRecentActivity();
+  if (logId === undefined) {
+    if (logs.length === 0) {
+      console.log("No recent sessions.");
+      return;
+    }
+    for (let i = 0;i < Math.min(logs.length, 20); i++) {
+      const log2 = logs[i];
+      const date = log2.modified ? new Date(log2.modified).toLocaleString() : "unknown";
+      const title = log2.title || log2.sessionId || "untitled";
+      console.log(`  ${i}: ${title}  (${date})`);
+    }
+    return;
+  }
+  const idx = typeof logId === "string" ? parseInt(logId, 10) : logId;
+  const log = Number.isFinite(idx) && idx >= 0 && idx < logs.length ? logs[idx] : logs.find((l) => l.sessionId === String(logId));
+  if (!log) {
+    console.error(`Session not found: ${logId}`);
+    process.exitCode = 1;
+    return;
+  }
+  console.log(JSON.stringify(log, null, 2));
+}
+async function errorHandler(num) {
+  const logs = await getRecentActivity();
+  const count = num ?? 5;
+  console.log(`Last ${count} sessions:`);
+  for (let i = 0;i < Math.min(count, logs.length); i++) {
+    const log = logs[i];
+    const date = log.modified ? new Date(log.modified).toLocaleString() : "unknown";
+    console.log(`  ${i}: ${log.sessionId}  (${date})`);
+  }
+}
+async function exportHandler(source, outputFile) {
+  const { writeFile, readFile } = await import("fs/promises");
+  const logs = await getRecentActivity();
+  const idx = parseInt(source, 10);
+  let log;
+  if (Number.isFinite(idx) && idx >= 0 && idx < logs.length) {
+    log = logs[idx];
+  } else {
+    log = logs.find((l) => l.sessionId === source);
+  }
+  if (!log) {
+    try {
+      const content = await readFile(source, "utf-8");
+      await writeFile(outputFile, content, "utf-8");
+      console.log(`Exported ${source} \u2192 ${outputFile}`);
+      return;
+    } catch {
+      console.error(`Source not found: ${source}`);
+      process.exitCode = 1;
+      return;
+    }
+  }
+  await writeFile(outputFile, JSON.stringify(log, null, 2), "utf-8");
+  console.log(`Exported session ${log.sessionId} \u2192 ${outputFile}`);
+}
+async function completionHandler(shell, opts, _program) {
+  const { regenerateCompletionCache } = await import("./chunk-z1r3z6w6.js");
+  if (opts.output) {
+    await regenerateCompletionCache();
+    console.log(`Completion cache regenerated for ${shell}.`);
+  } else {
+    await regenerateCompletionCache();
+    console.log(`Completion cache regenerated for ${shell}.`);
+  }
+}
+export {
+  taskUpdateHandler,
+  taskListHandler,
+  taskGetHandler,
+  taskDirHandler,
+  taskCreateHandler,
+  logHandler,
+  exportHandler,
+  errorHandler,
+  completionHandler
+};

package/dist/chunk-zga50181.js

@@ -0,0 +1,342 @@
+// @bun
+import {
+  getPlatform,
+  init_debug,
+  init_envUtils,
+  init_log,
+  init_platform,
+  isEnvTruthy,
+  isRunningOnHomespace,
+  logError,
+  logForDebugging
+} from "./chunk-s3hafnk3.js";
+import"./chunk-kb3758f7.js";
+import"./chunk-9h9k5vz3.js";
+import"./chunk-xmpgmeb8.js";
+import"./chunk-2kz09j2s.js";
+import"./chunk-c0k7b0jw.js";
+import {
+  __esm,
+  __require
+} from "./chunk-hhsxm2yr.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-6kjh280m.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 RedScope AI 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 RedScope AI 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
+};

package/dist/chunk-zhb2pns1.js

@@ -0,0 +1,44 @@
+// @bun
+import {
+  require_src as require_src2
+} from "./chunk-fh8bd39r.js";
+import {
+  require_src as require_src3
+} from "./chunk-cep7e37k.js";
+import {
+  require_src1 as require_src
+} from "./chunk-e4dsy4g1.js";
+import"./chunk-326zehp8.js";
+import"./chunk-kc67kt75.js";
+import"./chunk-40t1d75v.js";
+import"./chunk-e3abfxpy.js";
+import {
+  __commonJS
+} from "./chunk-hhsxm2yr.js";
+
+// node_modules/.bun/@opentelemetry+exporter-metrics-otlp-grpc@0.215.0+e40b0dfdd726a224/node_modules/@opentelemetry/exporter-metrics-otlp-grpc/build/src/OTLPMetricExporter.js
+var require_OTLPMetricExporter = __commonJS((exports) => {
+  Object.defineProperty(exports, "__esModule", { value: true });
+  exports.OTLPMetricExporter = undefined;
+  var exporter_metrics_otlp_http_1 = require_src2();
+  var otlp_grpc_exporter_base_1 = require_src3();
+  var otlp_transformer_1 = require_src();
+
+  class OTLPMetricExporter extends exporter_metrics_otlp_http_1.OTLPMetricExporterBase {
+    constructor(config) {
+      super((0, otlp_grpc_exporter_base_1.createOtlpGrpcExportDelegate)((0, otlp_grpc_exporter_base_1.convertLegacyOtlpGrpcOptions)(config ?? {}, "METRICS"), otlp_transformer_1.ProtobufMetricsSerializer, "MetricsExportService", "/opentelemetry.proto.collector.metrics.v1.MetricsService/Export"), config);
+    }
+  }
+  exports.OTLPMetricExporter = OTLPMetricExporter;
+});
+
+// node_modules/.bun/@opentelemetry+exporter-metrics-otlp-grpc@0.215.0+e40b0dfdd726a224/node_modules/@opentelemetry/exporter-metrics-otlp-grpc/build/src/index.js
+var require_src4 = __commonJS((exports) => {
+  Object.defineProperty(exports, "__esModule", { value: true });
+  exports.OTLPMetricExporter = undefined;
+  var OTLPMetricExporter_1 = require_OTLPMetricExporter();
+  Object.defineProperty(exports, "OTLPMetricExporter", { enumerable: true, get: function() {
+    return OTLPMetricExporter_1.OTLPMetricExporter;
+  } });
+});
+export default require_src4();