@phuetz/code-buddy 1.3.2 → 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.3.1-GA-blueviolet?style=flat-square" alt="Version 1.3.1 GA"/>
+  <img src="https://img.shields.io/badge/v1.5.0-GA-blueviolet?style=flat-square" alt="Version 1.5.0 GA"/>
 </p>
 
 <br/>
@@ -101,13 +101,34 @@ An open-source, multi-provider AI coding agent with a terminal UI, an HTTP/WebSo
   <img src="docs/screenshots/self-audit-bug-1.png" alt="Self-audit bug found" width="820"/>
 </p>
 
+**On your phone — chat with the same agent over Telegram.** Code Buddy runs as a messaging-channel bot, so the agent you use in the terminal is reachable from your pocket. Real, unedited captures (the bot is named *"Lisa"* here). The system prompt and tools **scale to each question** — light and instant for plain chat, escalating to load tools only when the request needs them (the same on-demand pattern as Codex / Claude):
+
+<table>
+  <tr>
+    <td width="33%" align="center" valign="top">
+      <img src="docs/screenshots/telegram-companion-chat.jpg" alt="Telegram chat: instant greeting, the time, and tomorrow's live weather in Paris via web search" width="250"/><br/>
+      <sub><b>Chat + live tools, on demand</b><br/>"Bonjour" answers instantly; <i>"what time is it?"</i> and <i>"tomorrow's weather in Paris?"</i> pull the time and <b><code>web_search</code></b> tools — only when actually asked.</sub>
+    </td>
+    <td width="33%" align="center" valign="top">
+      <img src="docs/screenshots/telegram-companion-selfcode.jpg" alt="Telegram chat: the agent confirms it can read and inspect its own source code via view_file" width="250"/><br/>
+      <sub><b>Reads its own code</b><br/>Confirms it can inspect its own source (or any accessible file) via <code>view_file</code> — then introduces its recursive self-improvement →</sub>
+    </td>
+    <td width="33%" align="center" valign="top">
+      <img src="docs/screenshots/telegram-companion-recursive.jpg" alt="Telegram chat: the agent explains its recursive self-improvement — Manus-inspired lessons in RULE / PATTERN / CONTEXT categories, stored in .codebuddy/lessons.md" width="250"/><br/>
+      <sub><b>Improves itself across sessions</b><br/>The <code>lessons_*</code> loop (Manus-inspired): after each fix or success it extracts <b>RULE / PATTERN / CONTEXT</b> lessons, persisted to <code>.codebuddy/lessons.md</code> (project + global). <i>Accurate — matches its real source.</i></sub>
+    </td>
+  </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.2.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/agent/execution/tool-selection-strategy.js

@@ -39,7 +39,10 @@ const DEFAULT_CONFIG = {
     // "agent proposes, human approves" path, so the model must always see it (a
     // RAG-gated propose tool would rarely surface). `lessons_list` stays out
     // (admin-style, not needed per-turn). Wakes the dormant feature in lessons-tracker.ts.
-    alwaysInclude: ['view_file', 'bash', 'search', 'str_replace_editor', 'web_search', 'remember', 'memory_propose', 'lessons_add', 'lessons_propose', 'lessons_search'],
+    // `tool_search` is ALWAYS exposed so the model can discover & pull ANY tool
+    // on demand when the per-query TF-IDF subset missed it (progressive disclosure,
+    // like Codex/Claude). Without it, a tool outside the top-K is unreachable.
+    alwaysInclude: ['view_file', 'bash', 'search', 'str_replace_editor', 'web_search', 'remember', 'memory_propose', 'lessons_add', 'lessons_propose', 'lessons_search', 'tool_search'],
     useAdaptiveThreshold: true,
     enableCaching: true,
     cacheTTLMs: 5 * 60 * 1000, // 5 minutes

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/codebuddy/tools.js

@@ -399,6 +399,21 @@ export async function getAllCodeBuddyTools() {
             ? { ...t, function: { ...t.function, description: (t.function.description ?? '') + DEFER } }
             : t);
     }
+    // Populate the `tool_search` BM25 index so the model can DISCOVER any tool on
+    // demand (progressive disclosure, like Codex/Claude). It was never
+    // initialized, leaving tool_search blind ("No tools found"). Index the full
+    // set (built-in + MCP + plugin) so a tool outside the per-query TF-IDF subset
+    // is still reachable when the model calls tool_search.
+    try {
+        const { initToolSearchIndex } = await import('../tools/tool-search.js');
+        initToolSearchIndex(allTools.map((t) => ({
+            name: t.function.name,
+            description: t.function.description ?? '',
+        })));
+    }
+    catch {
+        // tool-search is optional — never block tool assembly.
+    }
     return allTools;
 }
 // ============================================================================

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

@@ -327,13 +327,8 @@ export async function registerAIMessageHandler(manager) {
     aiHandlerRegistered = true;
     manager.onMessage(async (message, channel) => {
         try {
-            const apiKey = process.env.GROK_API_KEY || process.env.XAI_API_KEY || '';
-            if (!apiKey) {
-                logger.warn('No API key for channel AI responses');
-                return;
-            }
-            const { checkDMPairing, getDMPairing, getRouteAgentConfig } = await import('../../channels/core.js');
-            // 1. Check DM pairing first
+            // 1. DM pairing gate — unapproved senders get a code, then we stop.
+            const { checkDMPairing, getDMPairing } = await import('../../channels/core.js');
             const pairingStatus = await checkDMPairing(message);
             if (!pairingStatus.approved) {
                 if (pairingStatus.code) {
@@ -347,14 +342,35 @@ export async function registerAIMessageHandler(manager) {
                 }
                 return;
             }
-            // 2. Resolve route-backed agent config
-            const agentConfig = getRouteAgentConfig(message);
-            // 3. Instantiate Agent with routed config
+            // Nothing to answer (e.g. a non-text message with no transcription).
+            if (!message.content || !message.content.trim()) {
+                return;
+            }
+            // 2. Context-adaptive agent reply (« comme Claude »): the agent's own
+            //    query-classifier + buildForQuery scale the system prompt to the
+            //    request (a greeting → minimal ~800B prompt, NOT the 73KB legacy),
+            //    and tools load on demand — RAG selects only the relevant ~15 and the
+            //    `tool_search` meta-tool pulls more when actually needed. Bounded
+            //    rounds keep a simple chat fast while a real task can still act.
+            const { resolveProviderFromEnv } = await import('../../fleet/peer-chat-client-factory.js');
+            const knownProviders = ['ollama', 'chatgpt', 'gemini', 'grok', 'anthropic'];
+            const preferredProvider = process.env.CODEBUDDY_PROVIDER && knownProviders.includes(process.env.CODEBUDDY_PROVIDER)
+                ? process.env.CODEBUDDY_PROVIDER
+                : 'auto';
+            const resolved = resolveProviderFromEnv(preferredProvider);
+            if (!resolved) {
+                logger.warn('No LLM provider for channel chat — set CODEBUDDY_PROVIDER + a provider key/env');
+                return;
+            }
+            const { getRouteAgentConfig } = await import('../../channels/core.js');
             const { CodeBuddyAgent } = await import('../../agent/codebuddy-agent.js');
-            const model = agentConfig.model || process.env.GROK_MODEL || 'grok-3-latest';
-            const maxRounds = agentConfig.maxToolRounds;
-            const agent = new CodeBuddyAgent(apiKey, process.env.GROK_BASE_URL, model, maxRounds);
-            // 4. Resume/Initialize session history
+            const agentConfig = getRouteAgentConfig(message);
+            const model = agentConfig.model || resolved.model;
+            const agent = new CodeBuddyAgent(resolved.apiKey || 'local', resolved.baseUrl, model, agentConfig.maxToolRounds ?? 6, // bounded (vs the 50-round default)
+            true, // useRAGToolSelection — relevant tools on demand, not all ~194
+            process.env.CODEBUDDY_CHANNEL_PROMPT_ID || 'auto', // minimal/adaptive prompt, not the 73KB legacy
+            process.cwd());
+            // Multi-turn: restore prior session history into the agent.
             const sessionKey = message.sessionKey || 'default-global';
             const sessionStore = agent.getSessionStore();
             let session = await sessionStore.loadSession(sessionKey);
@@ -371,27 +387,38 @@ export async function registerAIMessageHandler(manager) {
                 await sessionStore.saveSession(session);
             }
             await sessionStore.resumeSession(sessionKey);
-            const activeSession = session;
-            if (activeSession.messages && activeSession.messages.length > 0) {
-                const chatHistory = sessionStore.convertMessagesToChatEntries(activeSession.messages);
-                const messages = activeSession.messages.map(m => ({
+            if (session.messages && session.messages.length > 0) {
+                const chatHistory = sessionStore.convertMessagesToChatEntries(session.messages);
+                const priorMessages = session.messages.map((m) => ({
                     role: m.type === 'user' ? 'user' : 'assistant',
-                    content: m.content
+                    content: m.content,
                 }));
                 const historyRestorer = agent;
                 historyRestorer.historyManager.setChatHistory(chatHistory);
-                historyRestorer.historyManager.setMessages(messages);
+                historyRestorer.historyManager.setMessages(priorMessages);
             }
-            // 5. Run agent turn
             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) });
@@ -412,7 +439,10 @@ export async function instantiateChannel(config) {
     switch (config.type) {
         case 'telegram': {
             const { TelegramChannel } = await import('../../channels/telegram/index.js');
-            return new TelegramChannel({ botToken: config.token || '', ...opts });
+            // TelegramChannel reads `config.token` (client.ts) — pass `token`, not
+            // `botToken`, or it throws "Telegram bot token is required" and the
+            // channel never starts from channels.json / server intake.
+            return new TelegramChannel({ token: config.token || '', ...opts });
         }
         case 'discord': {
             const { DiscordChannel } = await import('../../channels/discord/index.js');

package/dist/input/text-to-speech.js

@@ -272,8 +272,23 @@ export class TextToSpeechManager extends EventEmitter {
     async speakWithPiper(text) {
         return new Promise((resolve, reject) => {
             const audioFile = path.join(this.tempDir, `tts_${Date.now()}.wav`);
+            // Resolve the Piper binary + voice model. Defaults to `piper` on PATH
+            // (no model), but honors the local-voice-stack convention shared with
+            // Cowork so a self-hosted Piper (e.g. ai-stack fr_FR-siwis-medium) works
+            // out of the box: COWORK_PIPER_BIN / COWORK_PIPER_VOICE (or the
+            // CODEBUDDY_* aliases, or a `.onnx` path set as the configured voice).
+            const piperBin = process.env.COWORK_PIPER_BIN || process.env.CODEBUDDY_PIPER_BIN || 'piper';
+            const voiceModel = process.env.COWORK_PIPER_VOICE ||
+                process.env.CODEBUDDY_PIPER_VOICE ||
+                (this.config.voice && this.config.voice.endsWith('.onnx')
+                    ? this.config.voice
+                    : undefined);
+            const piperArgs = ['--output_file', audioFile];
+            if (voiceModel) {
+                piperArgs.push('--model', voiceModel);
+            }
             // Piper reads from stdin and outputs to file
-            const piper = spawn('piper', ['--output_file', audioFile]);
+            const piper = spawn(piperBin, piperArgs);
             piper.stdin?.write(text);
             piper.stdin?.end();
             piper.on('close', (code) => {

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/dist/voice/local-whisper.d.ts

@@ -0,0 +1,9 @@
+export interface LocalWhisperOptions {
+    language?: string;
+    model?: string;
+    timeoutMs?: number;
+}
+/** Transcribe an audio file (wav/ogg/mp3/webm…) to text via local faster-whisper. */
+export declare function transcribeFile(audioPath: string, options?: LocalWhisperOptions): Promise<string>;
+/** True if a local faster-whisper interpreter looks available. */
+export declare function localWhisperAvailable(): boolean;

package/dist/voice/local-whisper.js

@@ -0,0 +1,93 @@
+/**
+ * Local speech-to-text via faster-whisper ($0, offline).
+ *
+ * Wraps a self-hosted faster-whisper venv (the same local voice stack Cowork
+ * uses — e.g. ~/DEV/ai-stack/voice/.venv) as a reusable `audioFile -> text`
+ * helper. One-shot per call (model loads in ~1-2s on int8 CPU), which is fine
+ * for occasional clips (Telegram voice notes, a CLI turn). No cloud, no key.
+ *
+ * Engine selection (first existing wins):
+ *   CODEBUDDY_VOICE_PYTHON | COWORK_VOICE_PYTHON  (explicit interpreter)
+ *   ~/.codebuddy/voice/.venv/bin/python
+ *   ~/DEV/ai-stack/voice/.venv/bin/python
+ *   ~/ai-stack/voice/.venv/bin/python
+ *   python3 (PATH fallback)
+ * Model: CODEBUDDY_WHISPER_MODEL | COWORK_WHISPER_MODEL | "base".
+ */
+import { spawn } from 'node:child_process';
+import { existsSync } from 'node:fs';
+import { homedir } from 'node:os';
+import { join } from 'node:path';
+function resolvePython() {
+    const candidates = [
+        process.env.CODEBUDDY_VOICE_PYTHON,
+        process.env.COWORK_VOICE_PYTHON,
+        join(homedir(), '.codebuddy/voice/.venv/bin/python'),
+        join(homedir(), 'DEV/ai-stack/voice/.venv/bin/python'),
+        join(homedir(), 'ai-stack/voice/.venv/bin/python'),
+    ].filter((c) => Boolean(c));
+    for (const c of candidates) {
+        if (existsSync(c))
+            return c;
+    }
+    return 'python3';
+}
+const WHISPER_SCRIPT = `
+import sys, json
+from faster_whisper import WhisperModel
+audio, model, lang = sys.argv[1], sys.argv[2], (sys.argv[3] or None)
+m = WhisperModel(model, device="cpu", compute_type="int8")
+segs, _info = m.transcribe(audio, language=lang, vad_filter=True, beam_size=1)
+print(json.dumps({"text": " ".join(s.text.strip() for s in segs).strip()}))
+`;
+/** Transcribe an audio file (wav/ogg/mp3/webm…) to text via local faster-whisper. */
+export async function transcribeFile(audioPath, options = {}) {
+    const language = options.language ?? 'fr';
+    const model = options.model ||
+        process.env.CODEBUDDY_WHISPER_MODEL ||
+        process.env.COWORK_WHISPER_MODEL ||
+        'base';
+    const timeoutMs = options.timeoutMs ?? 120_000;
+    if (!existsSync(audioPath)) {
+        throw new Error(`local-whisper: audio file not found: ${audioPath}`);
+    }
+    return new Promise((resolve, reject) => {
+        const py = resolvePython();
+        const proc = spawn(py, ['-c', WHISPER_SCRIPT, audioPath, model, language], {
+            stdio: ['ignore', 'pipe', 'pipe'],
+        });
+        let stdout = '';
+        let stderr = '';
+        const timer = setTimeout(() => {
+            proc.kill('SIGKILL');
+            reject(new Error(`local-whisper: timed out after ${timeoutMs}ms`));
+        }, timeoutMs);
+        proc.stdout.on('data', (d) => (stdout += d.toString()));
+        proc.stderr.on('data', (d) => (stderr += d.toString()));
+        proc.on('error', (e) => {
+            clearTimeout(timer);
+            reject(new Error(`local-whisper: failed to spawn ${py}: ${e.message}`));
+        });
+        proc.on('close', (code) => {
+            clearTimeout(timer);
+            if (code !== 0) {
+                reject(new Error(`local-whisper: exited ${code}: ${stderr.trim().slice(-300)}`));
+                return;
+            }
+            try {
+                const line = stdout.trim().split('\n').filter(Boolean).pop() || '{}';
+                const parsed = JSON.parse(line);
+                resolve((parsed.text || '').trim());
+            }
+            catch (e) {
+                reject(new Error(`local-whisper: bad output: ${String(e)} :: ${stdout.slice(-200)}`));
+            }
+        });
+    });
+}
+/** True if a local faster-whisper interpreter looks available. */
+export function localWhisperAvailable() {
+    const py = resolvePython();
+    return py !== 'python3' || Boolean(process.env.CODEBUDDY_VOICE_PYTHON);
+}
+//# sourceMappingURL=local-whisper.js.map

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@phuetz/code-buddy",
-  "version": "1.3.2",
+  "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": {