@phuetz/code-buddy 1.3.2 → 1.4.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.4.0-GA-blueviolet?style=flat-square" alt="Version 1.4.0 GA"/>
 </p>
 
 <br/>
@@ -101,13 +101,32 @@ 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>
+
 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.4.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/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,18 +387,16 @@ 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) : '';
@@ -412,7 +426,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-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.4.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": {