@ch4p/cli 0.1.0

package/dist/chunk-WL32AHUY.js

@@ -0,0 +1,655 @@
+// ../../packages/voice/dist/index.js
+import { EventEmitter } from "events";
+import { EventEmitter as EventEmitter2 } from "events";
+import { spawn, execSync } from "child_process";
+import { writeFileSync, unlinkSync, mkdtempSync } from "fs";
+import { join } from "path";
+import { tmpdir } from "os";
+import { execFile as execFileCb } from "child_process";
+import { promisify } from "util";
+import { EventEmitter as EventEmitter3 } from "events";
+var VoiceProcessor = class {
+  stt;
+  tts;
+  config;
+  constructor(opts) {
+    this.stt = opts.stt;
+    this.tts = opts.tts;
+    this.config = opts.config;
+  }
+  /**
+   * Process an inbound message, transcribing any audio attachments.
+   *
+   * If no STT provider is configured or the message has no audio attachments,
+   * the message is returned unchanged.
+   *
+   * For each audio attachment that carries a `data` Buffer, the provider
+   * transcribes it directly. Attachments that only have a `url` are skipped
+   * (the caller is responsible for downloading the audio first).
+   *
+   * The transcript is prepended to the message text as "[Voice message]: ...".
+   *
+   * @param msg - The inbound message to process.
+   * @returns The message with transcripts prepended to the text.
+   */
+  async processInbound(msg) {
+    if (!this.stt || !this.config.enabled) {
+      return msg;
+    }
+    const audioAttachments = (msg.attachments ?? []).filter(
+      (a) => a.type === "audio"
+    );
+    if (audioAttachments.length === 0) {
+      return msg;
+    }
+    const transcripts = [];
+    for (const attachment of audioAttachments) {
+      if (attachment.data) {
+        const mimeType = attachment.mimeType ?? "audio/webm";
+        const transcript = await this.stt.transcribe(attachment.data, mimeType);
+        if (transcript) {
+          transcripts.push(transcript);
+        }
+      }
+    }
+    if (transcripts.length === 0) {
+      return msg;
+    }
+    const voiceText = transcripts.map((t) => `[Voice message]: ${t}`).join("\n");
+    const newText = msg.text ? `${voiceText}
+${msg.text}` : voiceText;
+    return { ...msg, text: newText };
+  }
+  /**
+   * Process an outbound message, synthesizing audio from the text.
+   *
+   * If no TTS provider is configured or voice is disabled, the message is
+   * returned unchanged.
+   *
+   * The synthesized audio is added as an attachment to the message.
+   *
+   * @param msg - The outbound message to process.
+   * @returns The message with an audio attachment added.
+   */
+  async processOutbound(msg) {
+    if (!this.tts || !this.config.enabled) {
+      return msg;
+    }
+    if (!msg.text) {
+      return msg;
+    }
+    const { audio, mimeType } = await this.tts.synthesize(msg.text);
+    const audioAttachment = {
+      type: "audio",
+      data: audio,
+      mimeType,
+      filename: "response.mp3"
+    };
+    const existingAttachments = msg.attachments ?? [];
+    return {
+      ...msg,
+      attachments: [...existingAttachments, audioAttachment]
+    };
+  }
+};
+var WhisperSTT = class {
+  apiKey;
+  constructor(config) {
+    this.apiKey = config.apiKey;
+  }
+  /**
+   * Transcribe an audio buffer to text using OpenAI Whisper.
+   *
+   * @param audio  - Raw audio data as a Buffer.
+   * @param mimeType - MIME type of the audio (e.g. 'audio/webm', 'audio/mp3').
+   * @returns The transcribed text.
+   */
+  async transcribe(audio, mimeType) {
+    const ext = mimeTypeToExtension(mimeType);
+    const blob = new Blob([audio], { type: mimeType });
+    const form = new FormData();
+    form.append("file", blob, `audio.${ext}`);
+    form.append("model", "whisper-1");
+    const res = await fetch("https://api.openai.com/v1/audio/transcriptions", {
+      method: "POST",
+      headers: {
+        Authorization: `Bearer ${this.apiKey}`
+      },
+      body: form
+    });
+    if (!res.ok) {
+      const body = await res.text();
+      throw new Error(`Whisper STT failed (${res.status}): ${body}`);
+    }
+    const json = await res.json();
+    return json.text;
+  }
+};
+function mimeTypeToExtension(mimeType) {
+  const map = {
+    "audio/webm": "webm",
+    "audio/mp3": "mp3",
+    "audio/mpeg": "mp3",
+    "audio/mp4": "mp4",
+    "audio/wav": "wav",
+    "audio/ogg": "ogg",
+    "audio/flac": "flac",
+    "audio/x-m4a": "m4a"
+  };
+  return map[mimeType] ?? "webm";
+}
+var DeepgramSTT = class {
+  apiKey;
+  constructor(config) {
+    this.apiKey = config.apiKey;
+  }
+  /**
+   * Transcribe an audio buffer to text using Deepgram Nova-3.
+   *
+   * @param audio    - Raw audio data as a Buffer.
+   * @param mimeType - MIME type of the audio (e.g. 'audio/webm', 'audio/wav').
+   * @returns The transcribed text.
+   */
+  async transcribe(audio, mimeType) {
+    const res = await fetch(
+      "https://api.deepgram.com/v1/listen?model=nova-3",
+      {
+        method: "POST",
+        headers: {
+          Authorization: `Token ${this.apiKey}`,
+          "Content-Type": mimeType
+        },
+        body: audio
+      }
+    );
+    if (!res.ok) {
+      const body = await res.text();
+      throw new Error(`Deepgram STT failed (${res.status}): ${body}`);
+    }
+    const json = await res.json();
+    return json.results.channels[0]?.alternatives[0]?.transcript ?? "";
+  }
+};
+var DEFAULT_VOICE_ID = "21m00Tcm4TlvDq8ikWAM";
+var ElevenLabsTTS = class {
+  apiKey;
+  voiceId;
+  constructor(config) {
+    this.apiKey = config.apiKey;
+    this.voiceId = config.voiceId ?? DEFAULT_VOICE_ID;
+  }
+  /**
+   * Synthesize text into audio using ElevenLabs.
+   *
+   * @param text - The text to convert to speech.
+   * @returns An object containing the audio Buffer and its MIME type.
+   */
+  async synthesize(text) {
+    const url = `https://api.elevenlabs.io/v1/text-to-speech/${this.voiceId}`;
+    const res = await fetch(url, {
+      method: "POST",
+      headers: {
+        "xi-api-key": this.apiKey,
+        "Content-Type": "application/json",
+        Accept: "audio/mpeg"
+      },
+      body: JSON.stringify({
+        text,
+        model_id: "eleven_flash_v2_5"
+      })
+    });
+    if (!res.ok) {
+      const body = await res.text();
+      throw new Error(`ElevenLabs TTS failed (${res.status}): ${body}`);
+    }
+    const arrayBuf = await res.arrayBuffer();
+    return {
+      audio: Buffer.from(arrayBuf),
+      mimeType: "audio/mpeg"
+    };
+  }
+};
+var VoiceActivityDetector = class extends EventEmitter {
+  energyThreshold;
+  silenceDurationMs;
+  minSpeechDurationMs;
+  isSpeaking = false;
+  speechStartTime = 0;
+  lastSpeechTime = 0;
+  speechBuffers = [];
+  silenceCheckTimer = null;
+  constructor(config = {}) {
+    super();
+    this.energyThreshold = config.energyThreshold ?? 500;
+    this.silenceDurationMs = config.silenceDurationMs ?? 800;
+    this.minSpeechDurationMs = config.minSpeechDurationMs ?? 300;
+  }
+  /**
+   * Process a chunk of raw PCM Int16LE audio samples.
+   *
+   * Call this repeatedly with audio data from the microphone.
+   * The VAD will emit `speech_start` and `speech_end` events as appropriate.
+   */
+  processSamples(pcmBuffer) {
+    const energy = this.computeRMS(pcmBuffer);
+    const now = Date.now();
+    if (energy >= this.energyThreshold) {
+      this.lastSpeechTime = now;
+      if (!this.isSpeaking) {
+        this.isSpeaking = true;
+        this.speechStartTime = now;
+        this.speechBuffers = [];
+        this.speechBuffers.push(Buffer.from(pcmBuffer));
+        this.emit("speech_start");
+      } else {
+        this.speechBuffers.push(Buffer.from(pcmBuffer));
+      }
+      this.scheduleSilenceCheck();
+    } else if (this.isSpeaking) {
+      this.speechBuffers.push(Buffer.from(pcmBuffer));
+      this.scheduleSilenceCheck();
+    }
+  }
+  /** Reset internal state. Call when stopping the listener. */
+  reset() {
+    this.isSpeaking = false;
+    this.speechStartTime = 0;
+    this.lastSpeechTime = 0;
+    this.speechBuffers = [];
+    if (this.silenceCheckTimer) {
+      clearTimeout(this.silenceCheckTimer);
+      this.silenceCheckTimer = null;
+    }
+  }
+  // -------------------------------------------------------------------------
+  // Private
+  // -------------------------------------------------------------------------
+  /** Compute root mean square energy of Int16LE PCM samples. */
+  computeRMS(buffer) {
+    const samples = buffer.length / 2;
+    if (samples === 0) return 0;
+    let sumSquares = 0;
+    for (let i = 0; i < buffer.length - 1; i += 2) {
+      const sample = buffer.readInt16LE(i);
+      sumSquares += sample * sample;
+    }
+    return Math.sqrt(sumSquares / samples);
+  }
+  /** Schedule a check for sustained silence after speech. */
+  scheduleSilenceCheck() {
+    if (this.silenceCheckTimer) {
+      clearTimeout(this.silenceCheckTimer);
+    }
+    this.silenceCheckTimer = setTimeout(() => {
+      this.silenceCheckTimer = null;
+      if (!this.isSpeaking) return;
+      const elapsed = Date.now() - this.lastSpeechTime;
+      if (elapsed >= this.silenceDurationMs) {
+        this.endSpeech();
+      }
+    }, this.silenceDurationMs + 50);
+  }
+  /** Finalize a speech segment. */
+  endSpeech() {
+    if (!this.isSpeaking) return;
+    const durationMs = Date.now() - this.speechStartTime;
+    this.isSpeaking = false;
+    if (durationMs < this.minSpeechDurationMs) {
+      this.speechBuffers = [];
+      return;
+    }
+    const audio = Buffer.concat(this.speechBuffers);
+    this.speechBuffers = [];
+    this.emit("speech_end", { audio, durationMs });
+  }
+};
+var MicCapture = class _MicCapture extends EventEmitter2 {
+  process = null;
+  sampleRate;
+  channels;
+  bitDepth;
+  device;
+  constructor(config = {}) {
+    super();
+    this.sampleRate = config.sampleRate ?? 16e3;
+    this.channels = config.channels ?? 1;
+    this.bitDepth = config.bitDepth ?? 16;
+    this.device = config.device;
+  }
+  /**
+   * Check whether `rec` (SoX) is available on PATH.
+   */
+  static isAvailable() {
+    try {
+      const cmd = process.platform === "win32" ? "where rec" : "which rec";
+      execSync(cmd, { stdio: "ignore" });
+      return true;
+    } catch {
+      return false;
+    }
+  }
+  /**
+   * Start capturing audio from the system microphone.
+   *
+   * Emits `data` events with raw PCM Int16LE buffers.
+   * Call `stop()` to terminate the capture.
+   *
+   * @throws If `rec` is not available or the process fails to start.
+   */
+  start() {
+    if (this.process) {
+      throw new Error("MicCapture is already running. Call stop() first.");
+    }
+    if (!_MicCapture.isAvailable()) {
+      throw new Error(
+        "SoX `rec` command not found on PATH. Install SoX: macOS `brew install sox`, Linux `apt install sox`."
+      );
+    }
+    const args = [
+      "-q",
+      // Quiet — suppress progress output
+      "-t",
+      "raw",
+      // Output raw PCM
+      "-b",
+      String(this.bitDepth),
+      // Bit depth
+      "-r",
+      String(this.sampleRate),
+      // Sample rate
+      "-c",
+      String(this.channels),
+      // Channels
+      "-e",
+      "signed-integer",
+      // Encoding
+      "-L",
+      // Little-endian byte order
+      "-"
+      // Output to stdout
+    ];
+    const env = { ...process.env };
+    if (this.device) {
+      env["AUDIODEV"] = this.device;
+    }
+    this.process = spawn("rec", args, {
+      stdio: ["ignore", "pipe", "ignore"],
+      env
+    });
+    this.process.stdout.on("data", (chunk) => {
+      this.emit("data", chunk);
+    });
+    this.process.on("error", (err) => {
+      this.emit("error", err);
+      this.process = null;
+    });
+    this.process.on("close", () => {
+      this.process = null;
+      this.emit("close");
+    });
+  }
+  /**
+   * Stop the microphone capture.
+   */
+  stop() {
+    if (!this.process) return;
+    try {
+      this.process.kill("SIGTERM");
+    } catch {
+    }
+    this.process = null;
+  }
+  /**
+   * Whether the microphone is currently capturing.
+   */
+  get isRunning() {
+    return this.process !== null;
+  }
+};
+var execFile = promisify(execFileCb);
+var EXTENSION_MAP = {
+  "audio/mpeg": ".mp3",
+  "audio/mp3": ".mp3",
+  "audio/wav": ".wav",
+  "audio/x-wav": ".wav",
+  "audio/ogg": ".ogg",
+  "audio/flac": ".flac",
+  "audio/aac": ".aac",
+  "audio/mp4": ".m4a",
+  "audio/webm": ".webm"
+};
+var AudioPlayback = class {
+  tempDir = null;
+  /**
+   * Play an audio buffer through the system speakers.
+   *
+   * Writes the buffer to a temp file, invokes the platform player,
+   * and cleans up after playback completes.
+   *
+   * @param audio - Raw audio data.
+   * @param mimeType - MIME type of the audio (e.g. 'audio/mpeg').
+   * @throws If no suitable playback command is available.
+   */
+  async play(audio, mimeType) {
+    if (!this.tempDir) {
+      this.tempDir = mkdtempSync(join(tmpdir(), "ch4p-audio-"));
+    }
+    const ext = EXTENSION_MAP[mimeType] ?? ".mp3";
+    const tempFile = join(this.tempDir, `playback-${Date.now()}${ext}`);
+    try {
+      writeFileSync(tempFile, audio);
+      if (process.platform === "darwin") {
+        await execFile("afplay", [tempFile]);
+      } else {
+        try {
+          await execFile("play", ["-q", tempFile]);
+        } catch {
+          if (ext === ".wav") {
+            await execFile("aplay", ["-q", tempFile]);
+          } else {
+            throw new Error(
+              "No audio playback command found. Install SoX (`apt install sox`) or use WAV format with ALSA (`aplay`)."
+            );
+          }
+        }
+      }
+    } finally {
+      try {
+        unlinkSync(tempFile);
+      } catch {
+      }
+    }
+  }
+};
+var WakeListener = class extends EventEmitter3 {
+  stt;
+  tts;
+  playback;
+  config;
+  mic = null;
+  vad = null;
+  running = false;
+  processing = false;
+  constructor(opts) {
+    super();
+    this.stt = opts.stt;
+    this.tts = opts.tts;
+    this.config = opts.config;
+    this.playback = new AudioPlayback();
+  }
+  /**
+   * Start listening for voice input.
+   *
+   * Opens the system microphone, runs VAD, and transcribes detected speech.
+   * Emits `wake` events when speech is successfully transcribed.
+   *
+   * @throws If microphone capture is not available (SoX not installed).
+   */
+  start() {
+    if (this.running) return;
+    if (!MicCapture.isAvailable()) {
+      throw new Error(
+        "Voice wake requires SoX for microphone capture. Install: macOS `brew install sox`, Linux `apt install sox`."
+      );
+    }
+    this.running = true;
+    this.vad = new VoiceActivityDetector({
+      energyThreshold: this.config.energyThreshold,
+      silenceDurationMs: this.config.silenceDurationMs,
+      minSpeechDurationMs: this.config.minSpeechDurationMs
+    });
+    this.mic = new MicCapture({
+      device: this.config.device
+    });
+    this.mic.on("data", (chunk) => {
+      if (this.vad && !this.processing) {
+        this.vad.processSamples(chunk);
+      }
+    });
+    this.mic.on("error", (err) => {
+      this.emit("error", err);
+    });
+    this.vad.on("speech_end", (segment) => {
+      void this.handleSpeechSegment(segment.audio, segment.durationMs);
+    });
+    this.mic.start();
+    this.emit("listening");
+  }
+  /**
+   * Stop listening.
+   */
+  stop() {
+    if (!this.running) return;
+    this.running = false;
+    if (this.mic) {
+      this.mic.stop();
+      this.mic.removeAllListeners();
+      this.mic = null;
+    }
+    if (this.vad) {
+      this.vad.reset();
+      this.vad.removeAllListeners();
+      this.vad = null;
+    }
+    this.emit("stopped");
+  }
+  /**
+   * Speak a text response through the system speakers.
+   *
+   * Uses the configured TTS provider to synthesize audio, then plays it
+   * via the platform-native playback command. If no TTS is configured,
+   * this is a no-op.
+   */
+  async speak(text) {
+    if (!this.tts || !text) return;
+    try {
+      const { audio, mimeType } = await this.tts.synthesize(text);
+      await this.playback.play(audio, mimeType);
+    } catch (err) {
+      this.emit("error", err instanceof Error ? err : new Error(String(err)));
+    }
+  }
+  /** Whether the listener is currently active. */
+  get isListening() {
+    return this.running;
+  }
+  // -------------------------------------------------------------------------
+  // Private
+  // -------------------------------------------------------------------------
+  /**
+   * Process a completed speech segment: transcribe and optionally filter by
+   * wake word.
+   */
+  async handleSpeechSegment(audio, durationMs) {
+    if (!this.running) return;
+    this.processing = true;
+    try {
+      const wavBuffer = this.wrapPCMAsWAV(audio);
+      const transcript = await this.stt.transcribe(wavBuffer, "audio/wav");
+      if (!transcript || transcript.trim().length === 0) {
+        return;
+      }
+      const text = transcript.trim();
+      if (this.config.wakeWord) {
+        const wakeWord = this.config.wakeWord.toLowerCase();
+        const lowerText = text.toLowerCase();
+        if (!lowerText.startsWith(wakeWord)) {
+          return;
+        }
+        const strippedText = text.slice(wakeWord.length).trim();
+        if (strippedText.length === 0) {
+          return;
+        }
+        this.emit("wake", {
+          text: strippedText,
+          durationMs,
+          wakeWordStripped: true
+        });
+      } else {
+        this.emit("wake", {
+          text,
+          durationMs,
+          wakeWordStripped: false
+        });
+      }
+    } catch (err) {
+      this.emit("error", err instanceof Error ? err : new Error(String(err)));
+    } finally {
+      this.processing = false;
+    }
+  }
+  /**
+   * Wrap raw PCM Int16LE data in a WAV container.
+   *
+   * STT providers (Whisper, Deepgram) expect audio in a recognized format.
+   * This creates a minimal WAV header for the raw PCM data.
+   */
+  wrapPCMAsWAV(pcm) {
+    const sampleRate = 16e3;
+    const channels = 1;
+    const bitsPerSample = 16;
+    const byteRate = sampleRate * channels * (bitsPerSample / 8);
+    const blockAlign = channels * (bitsPerSample / 8);
+    const dataSize = pcm.length;
+    const header = Buffer.alloc(44);
+    header.write("RIFF", 0);
+    header.writeUInt32LE(36 + dataSize, 4);
+    header.write("WAVE", 8);
+    header.write("fmt ", 12);
+    header.writeUInt32LE(16, 16);
+    header.writeUInt16LE(1, 20);
+    header.writeUInt16LE(channels, 22);
+    header.writeUInt32LE(sampleRate, 24);
+    header.writeUInt32LE(byteRate, 28);
+    header.writeUInt16LE(blockAlign, 32);
+    header.writeUInt16LE(bitsPerSample, 34);
+    header.write("data", 36);
+    header.writeUInt32LE(dataSize, 40);
+    return Buffer.concat([header, pcm]);
+  }
+};
+
+// src/system-prompt.ts
+function buildSystemPrompt(opts = {}) {
+  let prompt = "You are ch4p, a personal AI assistant. You are helpful, concise, and security-conscious. When asked to perform actions, respect the configured autonomy level.";
+  if (opts.hasMemory) {
+    prompt += " You have persistent memory \u2014 you can recall information from previous conversations and learn from interactions over time. Use the memory_store and memory_recall tools to explicitly save or retrieve specific information when helpful.";
+  }
+  if (opts.hasSearch) {
+    prompt += " You have web search capability \u2014 use the web_search tool to find current information, look up facts, or research topics when needed.";
+  }
+  if (opts.skillRegistry && opts.skillRegistry.size > 0) {
+    const descriptions = opts.skillRegistry.getDescriptions().map((s) => `  - ${s.name}: ${s.description}`).join("\n");
+    prompt += "\n\nAvailable skills (use the `load_skill` tool with the skill name to get full instructions):\n" + descriptions;
+  }
+  return prompt;
+}
+
+export {
+  VoiceProcessor,
+  WhisperSTT,
+  DeepgramSTT,
+  ElevenLabsTTS,
+  WakeListener,
+  buildSystemPrompt
+};