@phuetz/code-buddy 1.4.0 → 1.5.0

package/README.md

@@ -17,7 +17,7 @@
 <p align="center">
   <a href="https://github.com/phuetz/code-buddy/stargazers"><img src="https://img.shields.io/github/stars/phuetz/code-buddy?style=flat-square&logo=github&color=feca57&label=Star" alt="GitHub stars"/></a>
   <img src="https://img.shields.io/badge/Tests-27K%2B-00d26a?style=flat-square&logo=jest" alt="Tests"/>
-  <img src="https://img.shields.io/badge/v1.4.0-GA-blueviolet?style=flat-square" alt="Version 1.4.0 GA"/>
+  <img src="https://img.shields.io/badge/v1.5.0-GA-blueviolet?style=flat-square" alt="Version 1.5.0 GA"/>
 </p>
 
 <br/>
@@ -120,13 +120,15 @@ An open-source, multi-provider AI coding agent with a terminal UI, an HTTP/WebSo
   </tr>
 </table>
 
+🎙️ **And you can _talk_ to it.** Send a voice note and it replies by voice — speech-to-text (faster-whisper) and text-to-speech (Piper) both run **locally, `$0`**, mirroring your modality (voice in → voice out). Needs the local voice engines installed; it transparently degrades to a text reply otherwise.
+
 More desktop demos (Fleet, Autonomy, Companion, …) and captures: [`cowork/readme.md`](cowork/readme.md#demo) · [`docs/screenshots/`](docs/screenshots/README.md).
 
 ---
 
 ## What's shipped
 
-**1.4.0 GA — these aren't roadmap items.** The captures above are unedited, and the core runs today:
+**1.5.0 GA — these aren't roadmap items.** The captures above are unedited, and the core runs today:
 
 - ✅ **`$0` local coding agent** — a local Ollama model reasons on screen, then calls tools to do real work. *(the demos above)*
 - ✅ **ChatGPT Plus/Pro → `gpt-5.5` at `$0`** — `buddy login`, flat-fee, no API key, no per-token metering.

package/dist/channels/telegram/client.d.ts

@@ -137,6 +137,21 @@ export declare class TelegramChannel extends BaseChannel {
      * Build inline keyboard from buttons
      */
     private buildKeyboard;
+    /**
+     * Voice note → text. A Telegram voice/audio message arrives with no text but a
+     * voice attachment (file_id). Download it and transcribe it locally with
+     * faster-whisper (offline, $0) so the agent receives a normal text message —
+     * this is what lets you *talk* to the bot. No-op (and never throws) when there
+     * is already text, no audio attachment, or local Whisper isn't installed.
+     */
+    private maybeTranscribeVoice;
+    /**
+     * Answer by VOICE: synthesize `text` locally (Piper → OGG/Opus) and send it as
+     * a Telegram voice note via multipart upload. Used to mirror the user's
+     * modality — when they send a voice note, the bot can reply with one too.
+     * Throws on failure so the caller keeps the text reply as the fallback.
+     */
+    sendVoiceReply(channelId: string, text: string): Promise<void>;
     /**
      * Get file download URL
      */

package/dist/channels/telegram/client.js

@@ -401,6 +401,9 @@ export class TelegramChannel extends BaseChannel {
             return;
         }
         const message = this.convertMessage(msg);
+        // Voice note → text: transcribe locally (faster-whisper, $0, offline) so you
+        // can TALK to the bot — the agent then sees a normal text message.
+        await this.maybeTranscribeVoice(message);
         const parsed = this.parseCommand(message);
         // Attach session key for session isolation
         parsed.sessionKey = getSessionKey(parsed);
@@ -753,6 +756,79 @@ export class TelegramChannel extends BaseChannel {
         }
         return keyboard;
     }
+    /**
+     * Voice note → text. A Telegram voice/audio message arrives with no text but a
+     * voice attachment (file_id). Download it and transcribe it locally with
+     * faster-whisper (offline, $0) so the agent receives a normal text message —
+     * this is what lets you *talk* to the bot. No-op (and never throws) when there
+     * is already text, no audio attachment, or local Whisper isn't installed.
+     */
+    async maybeTranscribeVoice(message) {
+        if (message.content && message.content.trim())
+            return;
+        const audio = message.attachments?.find((a) => a.type === 'voice' || a.type === 'audio');
+        if (!audio?.url)
+            return;
+        try {
+            const { localWhisperAvailable, transcribeFile } = await import('../../voice/local-whisper.js');
+            if (!localWhisperAvailable()) {
+                logger.warn('[telegram] voice note received but local Whisper is unavailable — install the ai-stack voice venv (faster-whisper) to enable speech');
+                return;
+            }
+            const fileUrl = await this.getFileUrl(audio.url);
+            const res = await fetch(fileUrl);
+            if (!res.ok)
+                throw new Error(`download HTTP ${res.status}`);
+            const bytes = Buffer.from(await res.arrayBuffer());
+            const os = await import('node:os');
+            const path = await import('node:path');
+            const fs = await import('node:fs/promises');
+            const tmp = path.join(os.tmpdir(), `cb-tg-voice-${message.id}.ogg`);
+            await fs.writeFile(tmp, bytes);
+            try {
+                const text = await transcribeFile(tmp, { language: process.env.CODEBUDDY_VOICE_LANG || 'fr' });
+                if (text && text.trim()) {
+                    message.content = text.trim();
+                    message.contentType = 'text';
+                    logger.info(`[telegram] voice note transcribed → "${message.content.slice(0, 60)}…"`);
+                }
+            }
+            finally {
+                await fs.unlink(tmp).catch(() => undefined);
+            }
+        }
+        catch (err) {
+            logger.warn(`[telegram] voice transcription failed: ${err instanceof Error ? err.message : String(err)}`);
+        }
+    }
+    /**
+     * Answer by VOICE: synthesize `text` locally (Piper → OGG/Opus) and send it as
+     * a Telegram voice note via multipart upload. Used to mirror the user's
+     * modality — when they send a voice note, the bot can reply with one too.
+     * Throws on failure so the caller keeps the text reply as the fallback.
+     */
+    async sendVoiceReply(channelId, text) {
+        const { localTtsAvailable, synthesizeToOgg } = await import('../../voice/local-tts.js');
+        if (!localTtsAvailable())
+            throw new Error('local TTS (Piper) unavailable');
+        // Cap spoken length — a short reply is fine, avoid minutes of audio.
+        const spoken = text.length > 800 ? `${text.slice(0, 800)}…` : text;
+        const ogg = await synthesizeToOgg(spoken);
+        const fs = await import('node:fs/promises');
+        try {
+            const bytes = await fs.readFile(ogg);
+            const form = new FormData();
+            form.append('chat_id', channelId);
+            form.append('voice', new Blob([bytes], { type: 'audio/ogg' }), 'voice.ogg');
+            const url = `${TELEGRAM_API_BASE}/bot${this.telegramConfig.token}/sendVoice`;
+            const res = await fetch(url, { method: 'POST', body: form });
+            if (!res.ok)
+                throw new Error(`sendVoice HTTP ${res.status}`);
+        }
+        finally {
+            await fs.unlink(ogg).catch(() => undefined);
+        }
+    }
     /**
      * Get file download URL
      */

package/dist/commands/handlers/channel-handlers.js

@@ -400,12 +400,25 @@ export async function registerAIMessageHandler(manager) {
             const entries = await agent.processUserMessage(message.content);
             const lastEntry = entries[entries.length - 1];
             const response = lastEntry ? String(lastEntry.content) : '';
-            // 6. Deliver reply
+            // 6. Deliver reply (text)
             await channel.send({
                 channelId: message.channel.id,
                 content: response,
                 replyTo: message.id,
             });
+            // 7. If the user SPOKE (voice note), answer by voice too — mirror the
+            //    modality. Best-effort: the text reply already landed, so a TTS/upload
+            //    failure (or a channel without voice support) is a no-op, never fatal.
+            const userSpoke = message.attachments?.some((a) => a.type === 'voice' || a.type === 'audio');
+            const voiceChannel = channel;
+            if (userSpoke && response.trim() && typeof voiceChannel.sendVoiceReply === 'function') {
+                try {
+                    await voiceChannel.sendVoiceReply(message.channel.id, response);
+                }
+                catch (voiceErr) {
+                    logger.warn(`Voice reply skipped: ${voiceErr instanceof Error ? voiceErr.message : String(voiceErr)}`);
+                }
+            }
         }
         catch (err) {
             logger.error('Channel AI response failed', { error: err instanceof Error ? err.message : String(err) });

package/dist/voice/local-tts.d.ts

@@ -0,0 +1,13 @@
+/** True when a real Piper binary (not just the bare `piper` fallback) is resolvable. */
+export declare function localTtsAvailable(): boolean;
+export interface LocalTtsOptions {
+    /** ffmpeg binary (default: `ffmpeg` on PATH). */
+    ffmpeg?: string;
+    timeoutMs?: number;
+}
+/**
+ * Synthesize `text` to an OGG/Opus file (Telegram voice-note format) and return
+ * its path. Caller is responsible for deleting the file. Throws if Piper or
+ * ffmpeg fail; callers should catch and fall back to a text-only reply.
+ */
+export declare function synthesizeToOgg(text: string, options?: LocalTtsOptions): Promise<string>;

package/dist/voice/local-tts.js

@@ -0,0 +1,103 @@
+/**
+ * Local text-to-speech → Telegram-ready voice note, fully offline / $0.
+ *
+ * Pipeline: Piper (neural TTS) writes a WAV, then ffmpeg transcodes it to
+ * OGG/Opus (the format Telegram voice notes require). Returns the .ogg path.
+ *
+ * Resolution mirrors local-whisper.ts: explicit env wins, else the ai-stack
+ * install is auto-discovered, else we fall back to `piper` on PATH. Never
+ * throws on a missing engine — callers should treat a null return / rejection
+ * as "voice reply unavailable" and keep the text reply.
+ */
+import { spawn } from 'node:child_process';
+import { existsSync } from 'node:fs';
+import { unlink } from 'node:fs/promises';
+import { homedir, tmpdir } from 'node:os';
+import { join } from 'node:path';
+function resolvePiperBin() {
+    const candidates = [
+        process.env.COWORK_PIPER_BIN,
+        process.env.CODEBUDDY_PIPER_BIN,
+        join(homedir(), 'DEV/ai-stack/voice/piper/piper/piper'),
+        join(homedir(), 'ai-stack/voice/piper/piper/piper'),
+    ].filter((c) => Boolean(c));
+    for (const c of candidates) {
+        if (existsSync(c))
+            return c;
+    }
+    return 'piper';
+}
+function resolvePiperVoice() {
+    const candidates = [
+        process.env.COWORK_PIPER_VOICE,
+        process.env.CODEBUDDY_PIPER_VOICE,
+        join(homedir(), 'DEV/ai-stack/voice/voices/fr_FR-siwis-medium.onnx'),
+        join(homedir(), 'ai-stack/voice/voices/fr_FR-siwis-medium.onnx'),
+    ].filter((c) => Boolean(c));
+    for (const c of candidates) {
+        if (existsSync(c))
+            return c;
+    }
+    return undefined;
+}
+/** True when a real Piper binary (not just the bare `piper` fallback) is resolvable. */
+export function localTtsAvailable() {
+    return (resolvePiperBin() !== 'piper' ||
+        Boolean(process.env.COWORK_PIPER_BIN) ||
+        Boolean(process.env.CODEBUDDY_PIPER_BIN));
+}
+function run(cmd, args, opts) {
+    return new Promise((resolve, reject) => {
+        const child = spawn(cmd, args, { stdio: ['pipe', 'ignore', 'pipe'] });
+        let stderr = '';
+        const timer = setTimeout(() => {
+            child.kill('SIGKILL');
+            reject(new Error(`${cmd} timed out after ${opts.timeoutMs}ms`));
+        }, opts.timeoutMs);
+        child.stderr?.on('data', (d) => {
+            stderr += String(d);
+        });
+        child.on('error', (e) => {
+            clearTimeout(timer);
+            reject(e);
+        });
+        child.on('close', (code) => {
+            clearTimeout(timer);
+            if (code === 0)
+                resolve();
+            else
+                reject(new Error(`${cmd} exited ${code}: ${stderr.slice(-200)}`));
+        });
+        if (opts.stdin !== undefined) {
+            child.stdin?.write(opts.stdin);
+            child.stdin?.end();
+        }
+    });
+}
+/**
+ * Synthesize `text` to an OGG/Opus file (Telegram voice-note format) and return
+ * its path. Caller is responsible for deleting the file. Throws if Piper or
+ * ffmpeg fail; callers should catch and fall back to a text-only reply.
+ */
+export async function synthesizeToOgg(text, options = {}) {
+    const bin = resolvePiperBin();
+    const voice = resolvePiperVoice();
+    const ffmpeg = options.ffmpeg || 'ffmpeg';
+    const timeoutMs = options.timeoutMs ?? 60_000;
+    const stamp = `${process.pid}-${Date.now()}`;
+    const wav = join(tmpdir(), `cb-tts-${stamp}.wav`);
+    const ogg = join(tmpdir(), `cb-tts-${stamp}.ogg`);
+    const piperArgs = ['--output_file', wav];
+    if (voice)
+        piperArgs.push('--model', voice);
+    try {
+        await run(bin, piperArgs, { stdin: text, timeoutMs });
+        // Telegram voice notes want OGG/Opus mono. 32 kbps is plenty for speech.
+        await run(ffmpeg, ['-y', '-loglevel', 'error', '-i', wav, '-ac', '1', '-c:a', 'libopus', '-b:a', '32k', ogg], { timeoutMs });
+        return ogg;
+    }
+    finally {
+        await unlink(wav).catch(() => undefined);
+    }
+}
+//# sourceMappingURL=local-tts.js.map

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@phuetz/code-buddy",
-  "version": "1.4.0",
+  "version": "1.5.0",
   "description": "Open-source multi-provider AI coding agent for the terminal, desktop, and HTTP. 15 LLM providers (Grok, Claude, ChatGPT, Gemini, Ollama, LM Studio, …) with ~110 tools, a peer-to-peer fleet, opt-in self-improvement, multi-channel messaging, and a skills system.",
   "author": "Patrice Huetz <patrice.huetz@gmail.com>",
   "repository": {