@phuetz/code-buddy 1.5.1 → 1.6.1

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.5.1-GA-blueviolet?style=flat-square" alt="Version 1.5.1 GA"/>
+  <img src="https://img.shields.io/badge/v1.6.0-GA-blueviolet?style=flat-square" alt="Version 1.6.0 GA"/>
 </p>
 
 <br/>
@@ -128,7 +128,7 @@ More desktop demos (Fleet, Autonomy, Companion, …) and captures: [`cowork/read
 
 ## What's shipped
 
-**1.5.1 GA — these aren't roadmap items.** The captures above are unedited, and the core runs today:
+**1.6.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.
@@ -201,9 +201,13 @@ buddy --yolo                                       # full autonomy
 ```bash
 buddy llm                                    # list the LLMs you're logged into + the failover order
 buddy llm ensemble "is this approach sound?" # ask ChatGPT + Grok + Ollama together, then synthesize
+buddy council "compare REST vs GraphQL"      # route by capability, judge the best answer, LEARN which AI wins per task type
+buddy council --scoreboard                   # the learned ranking (which model is best for code / reasoning / …)
 CODEBUDDY_LLM_FAILOVER=1 buddy -p "…"         # if the primary errors, auto-continue on the next active LLM
 ```
 
+**`buddy council`** takes the ensemble further: it routes a task to the *best-suited* models by capability (and by their past win rate), an impartial judge keeps the single best answer, and a scoreboard **learns which AI is best for which kind of task** over time — so it gets smarter the more you use it. Works in Telegram too (`council <task>`).
+
 <p align="center">
   <img src="docs/assets/llm-demo.gif" alt="buddy llm lists your active LLMs, then auto-fails over from Grok to ChatGPT when the primary errors" width="760"/>
   <br/>

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

@@ -161,6 +161,11 @@ export declare class TelegramChannel extends BaseChannel {
      * Throws on failure so the caller keeps the text reply as the fallback.
      */
     sendVoiceReply(channelId: string, text: string): Promise<void>;
+    /**
+     * Send a local image file (e.g. a chart the agent generated) to the chat as a
+     * photo, via multipart sendPhoto. Lets the bot deliver visual artifacts.
+     */
+    sendImageFile(channelId: string, imagePath: string, caption?: string): Promise<void>;
     /**
      * Get file download URL
      */

package/dist/channels/telegram/client.js

@@ -388,15 +388,24 @@ export class TelegramChannel extends BaseChannel {
      * Handle an update
      */
     async handleUpdate(update) {
-        if (update.message) {
-            await this.handleMessage(update.message);
-        }
-        else if (update.edited_message) {
-            // Could emit 'message-edited' event
-            await this.handleMessage(update.edited_message);
+        // Guard the whole dispatch: a throw here used to be swallowed by the poll
+        // loop's catch, silently dropping the message with no trace.
+        try {
+            if (update.message) {
+                await this.handleMessage(update.message);
+            }
+            else if (update.edited_message) {
+                // Could emit 'message-edited' event
+                await this.handleMessage(update.edited_message);
+            }
+            else if (update.callback_query) {
+                await this.handleCallbackQuery(update.callback_query);
+            }
         }
-        else if (update.callback_query) {
-            await this.handleCallbackQuery(update.callback_query);
+        catch (e) {
+            logger.error('Telegram update handler error', {
+                err: e instanceof Error ? (e.stack || e.message) : String(e),
+            });
         }
     }
     /**
@@ -445,8 +454,13 @@ export class TelegramChannel extends BaseChannel {
                 return;
             }
         }
-        // Route enhanced commands
-        if (parsed.isCommand && this.telegramConfig.enhancedCommands !== false) {
+        // Route enhanced commands — but let `council`/`conseil` fall through to the
+        // normal message path so the channel AI handler can convene the multi-LLM
+        // council (the pro command router doesn't own these).
+        const passthroughCommands = new Set(['council', 'conseil']);
+        if (parsed.isCommand &&
+            this.telegramConfig.enhancedCommands !== false &&
+            !passthroughCommands.has((parsed.commandName ?? '').toLowerCase())) {
             const handled = await this.routeEnhancedCommand(parsed, chatId, userId);
             if (handled)
                 return;
@@ -843,6 +857,26 @@ export class TelegramChannel extends BaseChannel {
             await fs.unlink(ogg).catch(() => undefined);
         }
     }
+    /**
+     * Send a local image file (e.g. a chart the agent generated) to the chat as a
+     * photo, via multipart sendPhoto. Lets the bot deliver visual artifacts.
+     */
+    async sendImageFile(channelId, imagePath, caption) {
+        const fs = await import('node:fs/promises');
+        const path = await import('node:path');
+        const bytes = await fs.readFile(imagePath);
+        const ext = (path.extname(imagePath).slice(1) || 'png').toLowerCase();
+        const mime = ext === 'jpg' || ext === 'jpeg' ? 'image/jpeg' : `image/${ext}`;
+        const form = new FormData();
+        form.append('chat_id', channelId);
+        if (caption)
+            form.append('caption', caption.slice(0, 1024));
+        form.append('photo', new Blob([bytes], { type: mime }), path.basename(imagePath));
+        const url = `${TELEGRAM_API_BASE}/bot${this.telegramConfig.token}/sendPhoto`;
+        const res = await fetch(url, { method: 'POST', body: form });
+        if (!res.ok)
+            throw new Error(`sendPhoto HTTP ${res.status}`);
+    }
     /**
      * Get file download URL
      */

package/dist/codebuddy/tools.js

@@ -237,8 +237,12 @@ export function convertMCPToolToCodeBuddyTool(mcpTool) {
         }
     };
 }
-/** Threshold: defer MCP schemas when there are more than this many MCP tools */
-const DEFERRED_SCHEMA_THRESHOLD = 30;
+/** Threshold: defer MCP schemas when there are more than this many MCP tools.
+ *  Deferred tools become param-less stubs that REQUIRE a `tool_search` round
+ *  before they can be called — many models skip that and fall back to `bash`,
+ *  so for moderate tool counts it's better to keep full schemas and let RAG
+ *  tool-selection pick the relevant ~15. Override with CODEBUDDY_MCP_DEFER_THRESHOLD. */
+const DEFERRED_SCHEMA_THRESHOLD = Number(process.env.CODEBUDDY_MCP_DEFER_THRESHOLD) || 30;
 /** Full MCP tool schemas stored for deferred retrieval */
 let _deferredMCPSchemas = null;
 /**

package/dist/commands/council.d.ts

@@ -0,0 +1,29 @@
+/**
+ * `buddy council "<task>"` — capability-aware multi-LLM router + ensemble + learning.
+ *
+ * Flow (most pieces already exist in the Fleet; this orchestrates them and adds
+ * the learning layer):
+ *  1. List usable LLMs            → buildActiveLlmRegistry (providers/active-llm-registry)
+ *  2. Route by capability         → strengths heuristic × (1 + historical win rate)
+ *  3. Ask several in parallel     → createParallelExecutor (agent/parallel) 'ensemble'
+ *  4. Judge → keep the best       → an impartial LLM scores anonymized, shuffled answers
+ *  5. Consensus on divergence     → computeTextConsensus (fleet/result-aggregator)
+ *  6. Learn / prefer the best     → ModelScoreboard records every outcome
+ */
+export interface CouncilOptions {
+    /** How many models to consult (default 3). */
+    count?: number;
+    /** Comma list of provider/model substrings to restrict candidates. */
+    models?: string;
+    /** Provider/model substring to use as the judge (default: a neutral strong model). */
+    judge?: string;
+    /** Override the inferred task type. */
+    taskType?: string;
+    /** commander sets this false on --no-consensus. */
+    consensus?: boolean;
+    /** Just print the learned scoreboard and exit. */
+    scoreboard?: boolean;
+}
+type Emit = (s: string) => void;
+export declare function runCouncil(task: string, opts: CouncilOptions, out: Emit): Promise<void>;
+export {};

package/dist/commands/council.js

@@ -0,0 +1,299 @@
+/**
+ * `buddy council "<task>"` — capability-aware multi-LLM router + ensemble + learning.
+ *
+ * Flow (most pieces already exist in the Fleet; this orchestrates them and adds
+ * the learning layer):
+ *  1. List usable LLMs            → buildActiveLlmRegistry (providers/active-llm-registry)
+ *  2. Route by capability         → strengths heuristic × (1 + historical win rate)
+ *  3. Ask several in parallel     → createParallelExecutor (agent/parallel) 'ensemble'
+ *  4. Judge → keep the best       → an impartial LLM scores anonymized, shuffled answers
+ *  5. Consensus on divergence     → computeTextConsensus (fleet/result-aggregator)
+ *  6. Learn / prefer the best     → ModelScoreboard records every outcome
+ */
+import { CodeBuddyClient } from '../codebuddy/client.js';
+import { computeTextConsensus } from '../fleet/result-aggregator.js';
+import { getModelScoreboard } from '../fleet/model-scoreboard.js';
+/** Per-model wall-clock cap so a slow model never blocks the council. */
+const COUNCIL_TIMEOUT_MS = Number(process.env.CODEBUDDY_COUNCIL_TIMEOUT_MS) || 45000;
+// --- capability heuristics (deriveStrengths in capability-registry is private) ---
+function inferStrengths(model) {
+    const m = model.toLowerCase();
+    const s = new Set(['tool-calling']);
+    if (/code|coder|codex/.test(m))
+        s.add('code');
+    if (/opus|gpt-5|o1|o3|reason|think|r1|qwq|deepseek/.test(m)) {
+        s.add('reasoning');
+        s.add('thinking');
+    }
+    if (/gpt-5|gemini|sonnet|opus|grok-[34]|grok-4/.test(m))
+        s.add('reasoning');
+    if (/flash|mini|fast|haiku|small|nano|:3b|:4b|:7b|:8b/.test(m)) {
+        s.add('fast');
+        s.add('cheap');
+    }
+    if (/gemini|pro|opus|sonnet|long|1m|200k|128k/.test(m))
+        s.add('long-context');
+    if (/mistral|qwen|gemma|mixtral/.test(m))
+        s.add('french');
+    if (/vision|gpt-4o|gpt-5|gemini|grok-2-vision/.test(m))
+        s.add('vision');
+    return [...s];
+}
+const TASK_REQUIRES = {
+    code: ['code', 'reasoning'],
+    reasoning: ['reasoning', 'thinking'],
+    french: ['french', 'reasoning'],
+    vision: ['vision'],
+    general: ['reasoning', 'fast'],
+};
+function inferTaskType(task) {
+    const t = task.toLowerCase();
+    if (/\b(code|fonction|function|bug|refactor|impl[ée]ment|classe|class|api|script|compile|regex|sql)\b/.test(t))
+        return 'code';
+    if (/\b(prouve|d[ée]montre|raisonn|reason|prove|analyse|strat[ée]gie|pourquoi|math|calcul|optimi)\b/.test(t))
+        return 'reasoning';
+    if (/\b(image|photo|capture|screenshot|diagram|graph)\b/.test(t))
+        return 'vision';
+    if (/[éèàçùêîô]/.test(task) || /\b(fran[çc]ais|france|french)\b/.test(t))
+        return 'french';
+    return 'general';
+}
+function matchScore(strengths, required) {
+    if (required.length === 0)
+        return 0.5;
+    const have = new Set(strengths);
+    const hits = required.filter((r) => have.has(r)).length;
+    return hits / required.length;
+}
+/** Pick top-K, favouring distinct providers for genuine diversity. */
+function pickDiverse(ranked, k) {
+    const picked = [];
+    const seen = new Set();
+    for (const r of ranked) {
+        if (picked.length >= k)
+            break;
+        if (seen.has(r.c.provider))
+            continue;
+        seen.add(r.c.provider);
+        picked.push(r);
+    }
+    for (const r of ranked) {
+        if (picked.length >= k)
+            break;
+        if (!picked.includes(r))
+            picked.push(r);
+    }
+    return picked;
+}
+function extractJson(text) {
+    if (!text)
+        return null;
+    try {
+        return JSON.parse(text);
+    }
+    catch {
+        /* not pure JSON */
+    }
+    const m = text.match(/\{[\s\S]*\}/);
+    if (m) {
+        try {
+            return JSON.parse(m[0]);
+        }
+        catch {
+            /* salvage failed */
+        }
+    }
+    return null;
+}
+async function judgeAnswers(client, task, answers) {
+    const scores = new Array(answers.length).fill(0);
+    // Shuffle to neutralise position bias; answers are already identity-blind.
+    const order = answers.map((_, i) => i);
+    for (let i = order.length - 1; i > 0; i--) {
+        const j = Math.floor(Math.random() * (i + 1));
+        [order[i], order[j]] = [order[j], order[i]];
+    }
+    const letters = order.map((_, i) => String.fromCharCode(65 + i));
+    const blocks = order
+        .map((origIdx, pos) => `### Réponse ${letters[pos]}\n${answers[origIdx].content.trim()}`)
+        .join('\n\n');
+    const sys = 'You are an impartial judge. You receive a task and several ANONYMOUS candidate answers ' +
+        '(A, B, C…). Score each from 0.0 to 1.0 on correctness, completeness and usefulness, then ' +
+        'pick the single best. Judge ONLY the content — you do not know which model wrote which. ' +
+        'Respond with STRICT JSON and nothing else: {"scores":{"A":0.0},"winner":"A","why":"one short sentence"}.';
+    const user = `TASK:\n${task}\n\nCANDIDATE ANSWERS:\n${blocks}\n\nReturn the JSON now.`;
+    let winnerIdx = 0;
+    let rationale = '';
+    try {
+        const resp = await Promise.race([
+            client.chat([
+                { role: 'system', content: sys },
+                { role: 'user', content: user },
+            ], []),
+            new Promise((_, reject) => setTimeout(() => reject(new Error(`judge timeout >${Math.round(COUNCIL_TIMEOUT_MS / 1000)}s`)), COUNCIL_TIMEOUT_MS)),
+        ]);
+        const text = resp?.choices?.[0]?.message?.content ?? '';
+        const json = extractJson(text);
+        if (json) {
+            for (let pos = 0; pos < order.length; pos++) {
+                const sc = Number(json.scores?.[letters[pos]]);
+                if (Number.isFinite(sc))
+                    scores[order[pos]] = Math.max(0, Math.min(1, sc));
+            }
+            const winLetter = String(json.winner ?? '').trim().toUpperCase().charAt(0);
+            const winPos = letters.indexOf(winLetter);
+            winnerIdx = winPos >= 0 ? order[winPos] : scores.indexOf(Math.max(...scores));
+            rationale = String(json.why ?? '').trim();
+        }
+        else {
+            winnerIdx = answers.reduce((b, a, i) => (a.content.length > answers[b].content.length ? i : b), 0);
+            rationale = '(juge: réponse non-JSON → choix par longueur)';
+        }
+    }
+    catch (err) {
+        winnerIdx = 0;
+        rationale = `(juge indisponible: ${err instanceof Error ? err.message : String(err)})`;
+    }
+    if (!(scores[winnerIdx] > 0))
+        scores[winnerIdx] = 1;
+    return { winnerIdx, scores, rationale };
+}
+function buildJudgeClient(picked, all, judgePref) {
+    const pickedModels = new Set(picked.map((p) => p.c.model));
+    let judge;
+    if (judgePref) {
+        const want = judgePref.toLowerCase();
+        judge = all.find((c) => c.provider.toLowerCase().includes(want) || c.model.toLowerCase().includes(want));
+    }
+    // Prefer a strong reasoning model that is NOT one of the candidates (neutral).
+    if (!judge) {
+        judge = all.find((c) => !pickedModels.has(c.model) && /gpt-5|opus|sonnet|gemini|grok-[34]|grok-4|o3|reason/.test(c.model.toLowerCase()));
+    }
+    if (!judge)
+        judge = picked[0]?.c;
+    if (!judge || !judge.apiKey)
+        return null;
+    try {
+        return new CodeBuddyClient(judge.apiKey, judge.model, judge.baseURL);
+    }
+    catch {
+        return null;
+    }
+}
+// --- main ---
+export async function runCouncil(task, opts, out) {
+    const scoreboard = getModelScoreboard();
+    if (opts.scoreboard) {
+        out(scoreboard.print(opts.taskType));
+        return;
+    }
+    if (!task || !task.trim()) {
+        out('Usage: buddy council "<task>"   (or --scoreboard to see what it has learned)');
+        return;
+    }
+    const { buildActiveLlmRegistry } = await import('../providers/active-llm-registry.js');
+    const registry = await buildActiveLlmRegistry({});
+    let candidates = registry.all.filter((c) => c.apiKey);
+    if (candidates.length === 0) {
+        out('No active LLMs detected. Run `buddy login`, set an API key, or start Ollama.');
+        return;
+    }
+    if (opts.models) {
+        const wanted = opts.models.split(',').map((s) => s.trim().toLowerCase()).filter(Boolean);
+        const filtered = candidates.filter((c) => wanted.some((w) => c.provider.toLowerCase().includes(w) || c.model.toLowerCase().includes(w)));
+        if (filtered.length)
+            candidates = filtered;
+    }
+    const taskType = (opts.taskType || inferTaskType(task)).toLowerCase();
+    const required = TASK_REQUIRES[taskType] ?? TASK_REQUIRES.general;
+    const ranked = candidates
+        .map((c) => {
+        const strengths = inferStrengths(c.model);
+        const cap = matchScore(strengths, required);
+        const hist = scoreboard.winRate(taskType, c.model);
+        const cheapBonus = c.costInputUsdPerMtok === 0 ? 0.05 : 0;
+        return { c, strengths, score: (cap + 0.1 + cheapBonus) * (1 + hist), hist };
+    })
+        .sort((a, b) => b.score - a.score);
+    const k = Math.max(1, Math.min(opts.count ?? 3, ranked.length));
+    const picked = pickDiverse(ranked, k);
+    out(`🧠 Council — tâche "${taskType}" → ${picked.length} IA : ` +
+        picked.map((p) => `${p.c.model}${p.hist > 0 ? ` (${Math.round(p.hist * 100)}% hist)` : ''}`).join(', '));
+    const settled = await Promise.allSettled(picked.map(async (p) => {
+        const client = new CodeBuddyClient(p.c.apiKey ?? '', p.c.model, p.c.baseURL);
+        const t0 = Date.now();
+        const resp = await Promise.race([
+            client.chat([{ role: 'user', content: task }], []),
+            new Promise((_, reject) => setTimeout(() => reject(new Error(`timeout >${Math.round(COUNCIL_TIMEOUT_MS / 1000)}s`)), COUNCIL_TIMEOUT_MS)),
+        ]);
+        const content = resp?.choices?.[0]?.message?.content ?? '';
+        if (!content.trim())
+            throw new Error('réponse vide');
+        const usage = resp?.usage;
+        return {
+            modelId: p.c.provider,
+            modelName: p.c.model,
+            content,
+            latency: Date.now() - t0,
+            tokensUsed: usage?.total_tokens ?? 0,
+            cost: ((usage?.prompt_tokens ?? 0) / 1_000_000) * p.c.costInputUsdPerMtok,
+        };
+    }));
+    const answers = settled
+        .filter((s) => s.status === 'fulfilled')
+        .map((s) => s.value);
+    settled.forEach((s, i) => {
+        if (s.status === 'rejected') {
+            const reason = s.reason instanceof Error ? s.reason.message : String(s.reason);
+            out(`  ⚠️ ${picked[i].c.model}: ${reason.slice(0, 120)}`);
+        }
+    });
+    if (answers.length === 0) {
+        out('❌ Toutes les IA ont échoué.');
+        return;
+    }
+    const judgeClient = buildJudgeClient(picked, candidates, opts.judge);
+    const verdict = judgeClient
+        ? await judgeAnswers(judgeClient, task, answers)
+        : {
+            winnerIdx: answers.reduce((b, a, i) => (a.content.length > answers[b].content.length ? i : b), 0),
+            scores: answers.map(() => 0.5),
+            rationale: '(aucun juge disponible)',
+        };
+    const sources = answers.map((a) => ({ peerId: a.modelId, model: a.modelName, text: a.content }));
+    const consensus = computeTextConsensus(sources);
+    // Learn: record every model's outcome for this task type.
+    const at = new Date().toISOString();
+    for (let i = 0; i < answers.length; i++) {
+        const provider = picked.find((p) => p.c.model === answers[i].modelName)?.c.provider ?? answers[i].modelId;
+        scoreboard.recordOutcome({
+            at,
+            taskType,
+            model: answers[i].modelName,
+            provider,
+            won: i === verdict.winnerIdx,
+            quality: verdict.scores[i] ?? 0,
+            latencyMs: answers[i].latency,
+            costUsd: answers[i].cost ?? 0,
+        });
+    }
+    const winner = answers[verdict.winnerIdx];
+    out(`\n🏆 Meilleure réponse — ${winner.modelName}${verdict.rationale ? ` : ${verdict.rationale}` : ''}\n`);
+    out(winner.content.trim());
+    if (opts.consensus !== false && answers.length > 1) {
+        const pct = Math.round(consensus.score * 100);
+        // Jaccard word-overlap on free-form prose is informational, NOT a verdict:
+        // two good answers phrased differently legitimately score low. The judge
+        // above is the real quality evaluator; this just flags how lexically close
+        // the wordings were (high overlap ⇒ the models genuinely converged).
+        out(`\n🤝 Accord lexical inter-IA : ${pct}% (recouvrement de mots — le juge ci-dessus évalue le fond).`);
+    }
+    out('\n📊 Détail par IA :');
+    for (let i = 0; i < answers.length; i++) {
+        const mark = i === verdict.winnerIdx ? '🏆' : '  ';
+        out(`${mark} ${answers[i].modelName.padEnd(22)} score ${(verdict.scores[i] ?? 0).toFixed(2)}  ` +
+            `${answers[i].latency}ms  ${answers[i].tokensUsed} tok`);
+    }
+    out(`\n${scoreboard.print(taskType)}`);
+}
+//# sourceMappingURL=council.js.map