@phuetz/code-buddy 1.6.1 → 2.1.0

package/dist/commands/cli/speak-command.js

@@ -10,31 +10,79 @@ import { logger } from '../../utils/logger.js';
 export function registerSpeakCommand(program) {
     program
         .command("speak [text...]")
-        .description("Synthesize speech using AudioReader TTS")
-        .option("--voice <voice>", "Voice ID to use (e.g., af_bella, ff_siwis)")
+        .description("Synthesize speech (AudioReader, Pocket, or expressive Voicebox)")
+        .option("--engine <engine>", "TTS engine: audioreader | pocket | voicebox")
+        .option("--voice <voice>", "Voice ID, Pocket preset/sample, or Voicebox profile")
+        .option("--language <lang>", "Language for Pocket or Voicebox")
         .option("--list-voices", "List available voices")
         .option("--speed <speed>", "Speaking speed (0.25-4.0)", "1.0")
-        .option("--format <format>", "Output format (wav, mp3)", "wav")
+        .option("--format <format>", "Output format (wav, ogg, mp3)", "wav")
+        .option("--out <file>", "Save synthesized audio to this file instead of playing it")
         .option("--url <url>", "AudioReader API URL", "http://localhost:8000")
+        .option("--voicebox-url <url>", "Voicebox API URL (defaults to CODEBUDDY_VOICEBOX_URL)")
         .action(async (textParts, opts) => {
-        const { AudioReaderTTSProvider } = await import("../../talk-mode/providers/audioreader-tts.js");
-        const provider = new AudioReaderTTSProvider();
-        await provider.initialize({
-            provider: 'audioreader',
-            enabled: true,
-            priority: 1,
-            settings: {
-                baseURL: opts.url,
-                defaultVoice: opts.voice,
-                speed: parseFloat(opts.speed),
-                format: opts.format,
-            },
-        });
-        const available = await provider.isAvailable();
-        if (!available) {
-            console.error("AudioReader is not running at " + opts.url);
-            console.error("Start it with: cd ~/claude/AudioReader && python main.py");
-            process.exit(1);
+        // Engine selection: explicit --engine wins, else CODEBUDDY_TTS_ENGINE, else audioreader.
+        const engine = (opts.engine ?? process.env.CODEBUDDY_TTS_ENGINE ?? 'audioreader').trim().toLowerCase();
+        let provider;
+        if (engine === 'pocket') {
+            const { PocketTTSProvider } = await import("../../talk-mode/providers/pocket-tts.js");
+            provider = new PocketTTSProvider();
+            await provider.initialize({
+                provider: 'pocket',
+                enabled: true,
+                priority: 1,
+                settings: {
+                    voice: opts.voice ?? process.env.CODEBUDDY_POCKET_VOICE ?? 'estelle',
+                    language: opts.language ?? process.env.CODEBUDDY_POCKET_LANG ?? 'french',
+                },
+            });
+            if (!(await provider.isAvailable())) {
+                console.error("pocket-tts not found. Install with: pip install pocket-tts (or install uv for `uvx pocket-tts`).");
+                process.exit(1);
+            }
+        }
+        else if (engine === 'voicebox') {
+            const { VoiceboxTTSProvider } = await import("../../talk-mode/providers/voicebox-tts.js");
+            provider = new VoiceboxTTSProvider();
+            await provider.initialize({
+                provider: 'voicebox',
+                enabled: true,
+                priority: 1,
+                settings: {
+                    baseURL: opts.voiceboxUrl ?? process.env.CODEBUDDY_VOICEBOX_URL,
+                    profile: opts.voice ?? process.env.CODEBUDDY_VOICEBOX_PROFILE,
+                    language: opts.language ?? process.env.CODEBUDDY_VOICEBOX_LANGUAGE ?? 'fr',
+                    engine: process.env.CODEBUDDY_VOICEBOX_ENGINE ?? 'qwen',
+                    modelSize: process.env.CODEBUDDY_VOICEBOX_MODEL_SIZE ?? '1.7B',
+                    instruct: process.env.CODEBUDDY_VOICEBOX_INSTRUCT,
+                },
+            });
+            if (!(await provider.isAvailable())) {
+                console.error("Voicebox or its configured profile is unavailable.");
+                console.error("Run `buddy assistant voicebox` to inspect the endpoint and profiles.");
+                process.exit(1);
+            }
+        }
+        else {
+            const { AudioReaderTTSProvider } = await import("../../talk-mode/providers/audioreader-tts.js");
+            provider = new AudioReaderTTSProvider();
+            await provider.initialize({
+                provider: 'audioreader',
+                enabled: true,
+                priority: 1,
+                settings: {
+                    baseURL: opts.url,
+                    defaultVoice: opts.voice,
+                    speed: parseFloat(opts.speed),
+                    format: opts.format,
+                },
+            });
+            if (!(await provider.isAvailable())) {
+                console.error("AudioReader is not running at " + opts.url);
+                console.error("Start the AudioReader HTTP service (default http://localhost:8000), or use --engine pocket.");
+                console.error("Tip: use `--engine pocket` for the on-CPU realtime voice, or `--engine voicebox` for the expressive GPU voice.");
+                process.exit(1);
+            }
         }
         if (opts.listVoices) {
             const voices = await provider.listVoices();
@@ -50,15 +98,30 @@ export function registerSpeakCommand(program) {
             console.error("No text provided. Usage: buddy speak \"Hello world\"");
             process.exit(1);
         }
+        const requestedFormat = (opts.format || 'wav').trim().toLowerCase();
+        const supportedFormats = new Set(['wav', 'ogg', 'mp3']);
+        if (!supportedFormats.has(requestedFormat)) {
+            console.error(`Unsupported --format '${opts.format}'. Supported: wav, ogg, mp3.`);
+            process.exit(1);
+        }
         const result = await provider.synthesize(text, {
             voice: opts.voice,
             rate: parseFloat(opts.speed),
-            format: opts.format,
+            format: requestedFormat,
         });
         const { execSync } = await import("child_process");
-        const { writeFileSync, unlinkSync } = await import("fs");
+        const { mkdirSync, writeFileSync, unlinkSync } = await import("fs");
         const { tmpdir } = await import("os");
-        const { join } = await import("path");
+        const { dirname, extname, join } = await import("path");
+        if (opts.out) {
+            mkdirSync(dirname(opts.out), { recursive: true });
+            const outputPath = extname(opts.out)
+                ? opts.out
+                : `${opts.out}.${requestedFormat}`;
+            writeFileSync(outputPath, result.audio);
+            console.log(`Audio saved to: ${outputPath} (${requestedFormat})`);
+            return;
+        }
         const tmpFile = join(tmpdir(), `codebuddy-speak-${Date.now()}.${result.format}`);
         writeFileSync(tmpFile, result.audio);
         try {

package/dist/commands/cli/tools-commands.js

@@ -8,6 +8,8 @@ import { buildDispatchToolFilter, getDispatchToolPolicy, normalizeDispatchProfil
 import { getBuiltinToolNames } from '../../codebuddy/tools.js';
 import { buildBrowserOperatorSessionDraft, buildInternetScoutPlan, renderBrowserOperatorSessionDraft, renderInternetScoutPlan, } from '../../browser-automation/index.js';
 import { installResearchScriptSkillCandidate, listMaterializedResearchScriptSkillCandidates, readMaterializedResearchScriptSkillCandidate, } from '../../agent/research-script-skill-candidate.js';
+import { getActiveToolMetadata } from '../../tools/metadata.js';
+import { resolveToolEffect } from '../../tools/tool-effect.js';
 function formatList(values) {
     return values.length > 0 ? values.join(', ') : 'none';
 }
@@ -134,54 +136,85 @@ function printSkillCandidateList(candidates, summary) {
 function formatCandidateKind(candidate) {
     return candidate.kind === 'learning' ? 'Learning Agent' : 'Research script';
 }
+function runToolsProfile(profileArg, toolNames, options) {
+    const normalized = normalizeToolsProfile(profileArg);
+    const inspectedTools = toolNames.length > 0 ? toolNames : getBuiltinToolNames();
+    const policy = getDispatchToolPolicy(normalized.profile);
+    const decisions = previewDispatchToolDecisions(normalized.profile, inspectedTools);
+    const filter = buildDispatchToolFilter(normalized.profile, inspectedTools);
+    if (options.json) {
+        console.log(JSON.stringify({
+            requestedProfile: profileArg,
+            profile: normalized.profile,
+            profileId: normalized.profileId,
+            toolCount: inspectedTools.length,
+            policy,
+            filter,
+            decisions: decisions.map((decision) => ({
+                ...decision,
+                effect: resolveToolEffect(decision.tool),
+            })),
+        }, null, 2));
+        return;
+    }
+    console.log(`\nTool profile: ${normalized.profileId}`);
+    if (profileArg !== normalized.profile && profileArg !== normalized.profileId) {
+        console.log(`  Requested: ${profileArg} (normalized to ${normalized.profile})`);
+    }
+    console.log(`  Policy: ${policy.policyProfile} / ${policy.defaultAction}`);
+    console.log(`  Summary: ${policy.summary}`);
+    console.log(`  Inspected tools: ${inspectedTools.length}`);
+    console.log(`  Effective allow: ${formatList(filter.enabledPatterns)}`);
+    console.log(`  Effective deny: ${formatList(filter.disabledPatterns)}`);
+    console.log('\nTool decisions:\n');
+    for (const decision of decisions) {
+        console.log(`  ${decision.tool}: ${decision.action}  effect=${resolveToolEffect(decision.tool)}`);
+        console.log(`    Groups: ${formatList(decision.groups)}`);
+        if (decision.matchedGroup) {
+            console.log(`    Matched group: ${decision.matchedGroup}`);
+        }
+        console.log(`    Reason: ${decision.reason}`);
+    }
+    console.log('');
+}
 export function registerToolsCommands(program) {
     const tools = program
         .command('tools')
         .description('Inspect tool profiles and effective tool availability');
+    tools.action(() => {
+        runToolsProfile('hermes-balanced', [], {});
+    });
     tools
-        .command('profile')
-        .description('Inspect a Hermes/Fleet tool profile against real or provided tools')
-        .argument('[profile]', 'profile id such as hermes-safe, fleet.hermes.review, or code', 'hermes-balanced')
-        .argument('[toolNames...]', 'optional tool names to inspect instead of the built-in list')
+        .command('catalog')
+        .description('List built-in tool metadata including the C5 effect class')
         .option('--json', 'output JSON')
-        .action((profileArg, toolNames, options) => {
-        const normalized = normalizeToolsProfile(profileArg);
-        const inspectedTools = toolNames.length > 0 ? toolNames : getBuiltinToolNames();
-        const policy = getDispatchToolPolicy(normalized.profile);
-        const decisions = previewDispatchToolDecisions(normalized.profile, inspectedTools);
-        const filter = buildDispatchToolFilter(normalized.profile, inspectedTools);
+        .action((options) => {
+        const catalog = getActiveToolMetadata().map((entry) => ({
+            name: entry.name,
+            category: entry.category,
+            effect: resolveToolEffect(entry.name, entry),
+            description: entry.description,
+            fleetSafe: entry.fleetSafe === true,
+        }));
         if (options.json) {
-            console.log(JSON.stringify({
-                requestedProfile: profileArg,
-                profile: normalized.profile,
-                profileId: normalized.profileId,
-                toolCount: inspectedTools.length,
-                policy,
-                filter,
-                decisions,
-            }, null, 2));
+            console.log(JSON.stringify({ count: catalog.length, tools: catalog }, null, 2));
             return;
         }
-        console.log(`\nTool profile: ${normalized.profileId}`);
-        if (profileArg !== normalized.profile && profileArg !== normalized.profileId) {
-            console.log(`  Requested: ${profileArg} (normalized to ${normalized.profile})`);
-        }
-        console.log(`  Policy: ${policy.policyProfile} / ${policy.defaultAction}`);
-        console.log(`  Summary: ${policy.summary}`);
-        console.log(`  Inspected tools: ${inspectedTools.length}`);
-        console.log(`  Effective allow: ${formatList(filter.enabledPatterns)}`);
-        console.log(`  Effective deny: ${formatList(filter.disabledPatterns)}`);
-        console.log('\nTool decisions:\n');
-        for (const decision of decisions) {
-            console.log(`  ${decision.tool}: ${decision.action}`);
-            console.log(`    Groups: ${formatList(decision.groups)}`);
-            if (decision.matchedGroup) {
-                console.log(`    Matched group: ${decision.matchedGroup}`);
-            }
-            console.log(`    Reason: ${decision.reason}`);
+        console.log(`\nTool catalog: ${catalog.length} tools\n`);
+        for (const tool of catalog) {
+            console.log(`  ${tool.name}  effect=${tool.effect}  category=${tool.category}`);
         }
         console.log('');
     });
+    tools
+        .command('profile')
+        .description('Inspect a Hermes/Fleet tool profile against real or provided tools')
+        .argument('[profile]', 'profile id such as hermes-safe, fleet.hermes.review, or code', 'hermes-balanced')
+        .argument('[toolNames...]', 'optional tool names to inspect instead of the built-in list')
+        .option('--json', 'output JSON')
+        .action((profileArg, toolNames, options) => {
+        runToolsProfile(profileArg, toolNames, options);
+    });
     const browserOperator = tools
         .command('browser-operator')
         .description('Preview Browser Operator session contracts without starting a browser');

package/dist/commands/cli/triage-command.d.ts

@@ -0,0 +1,8 @@
+/**
+ * buddy triage — write a local, redacted support bundle (src/doctor/triage.ts).
+ *
+ * Never sends anything and never launches an agent: the command to hand the
+ * prompt to a local agent is printed for the user to review and run.
+ */
+import type { Command } from 'commander';
+export declare function registerTriageCommand(program: Command): void;

package/dist/commands/cli/triage-command.js

@@ -0,0 +1,72 @@
+/**
+ * buddy triage — write a local, redacted support bundle (src/doctor/triage.ts).
+ *
+ * Never sends anything and never launches an agent: the command to hand the
+ * prompt to a local agent is printed for the user to review and run.
+ */
+import { readFileSync } from 'node:fs';
+import { dirname, join, resolve } from 'node:path';
+import { fileURLToPath } from 'node:url';
+function buddyVersion() {
+    try {
+        const here = dirname(fileURLToPath(import.meta.url));
+        for (const candidate of [join(here, '..', '..', '..', 'package.json'), join(here, '..', '..', 'package.json')]) {
+            try {
+                const pkg = JSON.parse(readFileSync(candidate, 'utf8'));
+                if (pkg.version && pkg.name?.includes('buddy'))
+                    return pkg.version;
+            }
+            catch { /* try next */ }
+        }
+    }
+    catch { /* fall through */ }
+    return 'unknown';
+}
+export function registerTriageCommand(program) {
+    program
+        .command('triage')
+        .description('Write a local redacted support bundle and a ≤ 8 KiB prompt (no network, launches nothing)')
+        .option('--json', 'Print a JSON summary on stdout')
+        .option('--out <dir>', 'Parent directory for the bundle (default ~/.codebuddy/triage)')
+        .option('--log-lines <n>', 'Maximum log lines to include', '200')
+        .action(async (options) => {
+        const { writeTriageBundle } = await import('../../doctor/triage.js');
+        const directory = program.opts().directory;
+        const cwd = resolve(process.cwd(), directory || process.cwd());
+        const logLines = Math.max(0, Math.min(2000, Number.parseInt(options.logLines ?? '200', 10) || 0));
+        try {
+            const result = await writeTriageBundle({
+                cwd,
+                ...(options.out ? { outParent: resolve(process.cwd(), options.out) } : {}),
+                logLines,
+                buddyVersion: buddyVersion(),
+            });
+            if (options.json) {
+                console.log(JSON.stringify({
+                    dir: result.dir,
+                    files: { json: result.jsonPath, prompt: result.promptPath },
+                    promptBytes: result.promptBytes,
+                    redactions: result.redactions,
+                    withheld: result.withheld,
+                    networkUsed: false,
+                    agentLaunched: false,
+                    suggestedCommand: result.suggestedCommand,
+                }, null, 2));
+                return;
+            }
+            console.log('\nCode Buddy triage (local only — nothing was sent, no agent was started)\n');
+            console.log(`  Bundle     : ${result.dir}`);
+            console.log(`  Prompt     : ${result.promptPath} (${result.promptBytes} bytes)`);
+            console.log(`  Redactions : ${result.redactions}`);
+            if (result.withheld.length > 0)
+                console.log(`  Withheld   : ${result.withheld.join(', ')} (secret scan still matched)`);
+            console.log('\nReview prompt.md, then hand it to a local agent yourself:');
+            console.log(`  ${result.suggestedCommand}\n`);
+        }
+        catch (error) {
+            console.error(`triage failed: ${error instanceof Error ? error.message : String(error)}`);
+            process.exitCode = 1;
+        }
+    });
+}
+//# sourceMappingURL=triage-command.js.map

package/dist/commands/cli/utility-commands.js

@@ -19,22 +19,62 @@ export function registerUtilityCommands(program) {
         .description('Diagnose Code Buddy environment, dependencies, and configuration')
         .option('-v, --verbose', 'Show all checks including passing ones')
         .option('--fix', 'Auto-fix issues that can be resolved automatically')
+        .option('--json', 'Print a stable JSON report (includes the Integrations section)')
+        .option('--offline', 'Skip every network call (live key checks, OAuth refresh, local runtime probes)')
+        .option('--integrations', 'Also check LM Resizer, Code Explorer, MCP config, resource catalog and skills (no network)')
         .action(async (options) => {
-        const { runDoctorChecks, runFixes } = await import('../../doctor/index.js');
-        const checks = await runDoctorChecks(resolveCommandDirectory(program));
+        const { runDoctorChecks, runFixes, summarizeDoctorChecks } = await import('../../doctor/index.js');
+        const cwd = resolveCommandDirectory(program);
+        const offline = options.offline === true;
+        const coreChecks = await runDoctorChecks(cwd, { offline });
+        const withIntegrations = options.json === true || options.integrations === true;
+        const integrationChecks = withIntegrations
+            ? await (await import('../../doctor/integrations.js')).runIntegrationChecks(cwd)
+            : [];
+        const checks = [...coreChecks, ...integrationChecks];
+        if (options.json) {
+            const { buildDoctorJsonReport } = await import('../../doctor/integrations.js');
+            const fixes = options.fix ? await runFixes(checks.filter((c) => c.fixable)) : undefined;
+            const summary = summarizeDoctorChecks(checks);
+            const report = buildDoctorJsonReport(checks, summary, { offline, ...(fixes ? { fixes } : {}) });
+            console.log(JSON.stringify(report, null, 2));
+            const readinessJson = checks.find((c) => c.name === 'AI provider ready');
+            if (summary.errors > 0 || (readinessJson && readinessJson.status !== 'ok') || fixes?.some((f) => !f.success)) {
+                process.exitCode = 1;
+            }
+            return;
+        }
         console.log('\n🔍 Code Buddy Doctor\n');
         const icons = { ok: '✅', warn: '⚠️', error: '❌' };
+        // Headline verdict: the first question a newcomer has is "can I chat yet?"
+        const readiness = checks.find((c) => c.name === 'AI provider ready');
+        if (readiness) {
+            if (readiness.status === 'ok') {
+                console.log(`  ✅ Ready to chat — a provider is configured (${readiness.message})`);
+                console.log('     Start now:  buddy         (or try the demo:  buddy try)');
+            }
+            else {
+                console.log(`  ⚠️  Not ready to chat yet — ${readiness.message}`);
+            }
+            console.log('');
+        }
         for (const check of checks) {
+            if (check.name === 'AI provider ready')
+                continue; // already shown as the headline
+            if (integrationChecks.length > 0 && check === integrationChecks[0])
+                console.log('\n  Integrations (no network):');
             if (options.verbose || check.status !== 'ok') {
                 const fixTag = check.fixable ? ' [fixable]' : '';
                 console.log(`  ${icons[check.status]} ${check.name}: ${check.message}${fixTag}`);
             }
         }
-        const errors = checks.filter(c => c.status === 'error').length;
-        const warns = checks.filter(c => c.status === 'warn').length;
-        const oks = checks.filter(c => c.status === 'ok').length;
+        const { passed: oks, warnings: warns, errors, optionalNotInstalled } = summarizeDoctorChecks(checks);
         const fixable = checks.filter(c => c.fixable).length;
+        const readinessNeedsAttention = readiness !== undefined && readiness.status !== 'ok';
         console.log(`\n  Summary: ${oks} passed, ${warns} warnings, ${errors} errors`);
+        if (optionalNotInstalled > 0) {
+            console.log(`  ${optionalNotInstalled} optional tool(s) not installed (not a problem)`);
+        }
         if (fixable > 0 && !options.fix) {
             console.log(`  ${fixable} issue(s) can be auto-fixed with --fix`);
         }
@@ -49,11 +89,18 @@ export function registerUtilityCommands(program) {
             const fixed = fixResults.filter(r => r.success).length;
             const failed = fixResults.filter(r => !r.success).length;
             console.log(`\n  Fix summary: ${fixed} fixed, ${failed} failed\n`);
-            if (failed > 0)
-                process.exit(1);
+            // A successful fix can resolve a fixable readiness warning (for
+            // example, selecting an already-running Ollama). A missing provider
+            // remains a real failure even if unrelated housekeeping was fixed.
+            const unresolvedReadiness = readinessNeedsAttention && !readiness?.fixable;
+            if (failed > 0 || errors > 0 || unresolvedReadiness)
+                process.exitCode = 1;
         }
-        else if (errors > 0) {
-            process.exit(1);
+        else if (errors > 0 || readinessNeedsAttention) {
+            // `doctor` is also useful in CI and scripts: a clear "not ready"
+            // verdict must not look successful merely because the warnings are
+            // non-fatal for an already-configured user.
+            process.exitCode = 1;
         }
     });
     // Security Audit command
@@ -92,7 +139,9 @@ export function registerUtilityCommands(program) {
         .description('Interactive setup wizard for Code Buddy')
         .action(async () => {
         const { runOnboarding } = await import('../../wizard/onboarding.js');
-        await runOnboarding();
+        const result = await runOnboarding();
+        if (!result)
+            process.exitCode = 2;
     });
     const ollamaCommand = program
         .command('ollama')

package/dist/commands/client-dispatcher.d.ts

@@ -24,6 +24,7 @@ export declare class ClientCommandDispatcher {
      * @returns true if the input was handled as a command, false otherwise.
      */
     static dispatch(input: string, context: ClientCommandContext): Promise<boolean>;
+    private static finishCommandWithMessage;
     private static handleSlashCommand;
     /**
      * Handles internal command tokens by delegating to EnhancedCommandHandler.
@@ -36,6 +37,13 @@ export declare class ClientCommandDispatcher {
      * result handling (add entry to chat, pass prompt to AI, clear input).
      */
     private static delegateToEnhanced;
+    /** Session-only /switch overrides, keyed by the live agent. */
+    private static readonly switchState;
+    /**
+     * Back /switch with the running agent so it changes the model used by the
+     * next turns (session only, unlike /model which also saves the preference).
+     */
+    private static createSwitchModelProvider;
     private static handleEnhancedCommand;
     private static handleModelSwitch;
     private static handleShellBypass;