@calliopelabs/cli 2.3.0 → 2.5.0

package/dist/ui/commands.js

@@ -21,6 +21,7 @@ import { getAgentStatusReport, swarmManager, councilManager, COUNCIL_TEMPLATES,
 import { smartRoute, getDefaultSmartRoutingConfig, detectTaskType } from '../smart-router.js';
 import { getCurrentSkin, getCurrentPalette, applySkin, applyPalette, listSkins, listPalettes } from '../hud/api.js';
 import { getCurrentCompanion, applyCompanion, listCompanions, getMoodText } from '../companions.js';
+import { scuttlebotClient } from '../scuttlebot/index.js';
 import { createJob, runJob, cancelJob, getJob, formatJob, formatJobsList, clearFinishedJobs } from '../background-jobs.js';
 import { listRecordings, loadRecording, formatRecording, deleteRecording } from '../terminal-recording.js';
 import { startApiServer, stopApiServer, isApiServerRunning } from '../api-server.js';
@@ -113,7 +114,7 @@ export async function handleCommand(cmd, ctx) {
   /persona [name]            - Switch personality
   /route [on|off]            - Auto model routing (/autoroute)
   /smart [on|off|cost|test]  - Cross-provider smart routing
-  /breaker [status|resume]   - Circuit breaker control (/cb)
+  /breaker [status|adjust]   - Circuit breaker control (/cb)
 
 --- Conversation ---
   /edit                      - Edit and resend last message
@@ -194,9 +195,17 @@ Modes: Plan | Hybrid | Work | Auto-route: ${ctx.autoRoute ? 'ON' : 'OFF'}${ctx.a
         case '/providers':
         case '/p':
             if (parts[1]) {
-                const p = parts[1].toLowerCase();
-                ctx.setProvider(p);
-                ctx.addMessage('system', `Provider: ${selectProvider(p)}`);
+                const requested = parts[1].toLowerCase();
+                const available = getAvailableProviders();
+                if (!available.includes(requested)) {
+                    ctx.addMessage('error', `Provider "${requested}" is not configured. Run /provider (no args) for an interactive picker with setup.`);
+                    break;
+                }
+                ctx.setProvider(requested);
+                ctx.addMessage('system', `Provider: ${selectProvider(requested)}`);
+            }
+            else if (ctx.openProviderPicker) {
+                ctx.openProviderPicker();
             }
             else {
                 ctx.addMessage('system', `Provider: ${ctx.actualProvider} | Available: ${getAvailableProviders().join(', ')}`);
@@ -226,7 +235,7 @@ Modes: Plan | Hybrid | Work | Auto-route: ${ctx.autoRoute ? 'ON' : 'OFF'}${ctx.a
             else {
                 ctx.addMessage('system', `Fetching models for ${ctx.actualProvider}...`);
                 try {
-                    const models = await getAvailableModels(ctx.actualProvider);
+                    const models = await getAvailableModels(ctx.actualProvider, { throwOnError: true });
                     if (models.length > 0) {
                         ctx.setAvailableModels(models);
                         ctx.setModalMode('model');
@@ -243,7 +252,7 @@ Modes: Plan | Hybrid | Work | Auto-route: ${ctx.autoRoute ? 'ON' : 'OFF'}${ctx.a
         case '/models':
             ctx.addMessage('system', `Fetching models for ${ctx.actualProvider}...`);
             try {
-                const models = await getAvailableModels(ctx.actualProvider);
+                const models = await getAvailableModels(ctx.actualProvider, { throwOnError: true });
                 if (models.length > 0) {
                     ctx.setAvailableModels(models);
                     ctx.setModalMode('model');
@@ -410,7 +419,91 @@ Modes: Plan | Hybrid | Work | Auto-route: ${ctx.autoRoute ? 'ON' : 'OFF'}${ctx.a
         case '/status':
         case '/s': {
             const imgInfo = getTerminalImageInfo();
-            ctx.addMessage('system', `${ctx.actualProvider}:${ctx.actualModel} | ${ctx.stats.messageCount} msgs | ${ctx.stats.inputTokens + ctx.stats.outputTokens} tokens | terminal: ${getImageModeLabel(imgInfo.mode)}${imgInfo.truecolor ? ' (truecolor)' : ''} ${imgInfo.width}cols`);
+            let statusMsg = `${ctx.actualProvider}:${ctx.actualModel} | ${ctx.stats.messageCount} msgs | ${ctx.stats.inputTokens + ctx.stats.outputTokens} tokens | terminal: ${getImageModeLabel(imgInfo.mode)}${imgInfo.truecolor ? ' (truecolor)' : ''} ${imgInfo.width}cols`;
+            // Add scuttlebot status if enabled
+            if (scuttlebotClient.isEnabled()) {
+                const sbStatus = scuttlebotClient.getStatus();
+                statusMsg += `\nScuttlebot: enabled (${sbStatus.nick}) | irc:${sbStatus.config?.ircAddr} | #${sbStatus.config?.channel}`;
+            }
+            ctx.addMessage('system', statusMsg);
+            break;
+        }
+        case '/scuttlebot': {
+            const subCmd = parts[1];
+            const sbStatus = scuttlebotClient.getStatus();
+            // /scuttlebot enable - enable mid-session
+            if (subCmd === 'enable') {
+                if (sbStatus.enabled) {
+                    ctx.addMessage('system', 'Scuttlebot is already enabled.');
+                    break;
+                }
+                // Initialize scuttlebot — config is loaded from ~/.config/scuttlebot-relay.env,
+                // process.env, and .scuttlebot.yaml inside initialize()
+                const sessionId = ctx.sessionRef.current?.id || 'default';
+                const cwd = getActiveProjectDir(ctx);
+                scuttlebotClient.initialize(sessionId, cwd).then(async (enabled) => {
+                    if (enabled) {
+                        const status = scuttlebotClient.getStatus();
+                        let msg = '✓ Scuttlebot enabled!\n';
+                        msg += `  Nick:      ${status.nick}\n`;
+                        msg += `  IRC:       ${status.config?.ircAddr}\n`;
+                        msg += `  Channel:   #${status.config?.channel}`;
+                        if (status.config?.channels && status.config.channels.length > 1) {
+                            msg += `\n  Channels:  ${status.config.channels.map((c) => '#' + c).join(', ')}`;
+                        }
+                        ctx.addMessage('system', msg);
+                        // Post online status and start routing IRC instructions
+                        await scuttlebotClient.postOnline();
+                        ctx.startScuttlebotPolling();
+                    }
+                    else {
+                        ctx.addMessage('system', 'Failed to enable scuttlebot');
+                    }
+                }).catch((err) => {
+                    ctx.addMessage('system', `Failed to enable scuttlebot: ${err instanceof Error ? err.message : String(err)}`);
+                });
+                break;
+            }
+            // /scuttlebot disable - disable mid-session
+            if (subCmd === 'disable') {
+                if (!sbStatus.enabled) {
+                    ctx.addMessage('system', 'Scuttlebot is not enabled.');
+                    break;
+                }
+                scuttlebotClient.postOffline().then(() => {
+                    return scuttlebotClient.disconnect();
+                }).then(() => {
+                    ctx.addMessage('system', 'Scuttlebot disabled');
+                }).catch((err) => {
+                    ctx.addMessage('system', `Error disabling scuttlebot: ${err instanceof Error ? err.message : String(err)}`);
+                });
+                break;
+            }
+            // Show status
+            if (!sbStatus.enabled) {
+                ctx.addMessage('system', 'Scuttlebot not enabled.\n\nRun: /scuttlebot enable\n\nConfig is loaded automatically from ~/.config/scuttlebot-relay.env\nChannel is read from .scuttlebot.yaml');
+                break;
+            }
+            let statusText = 'Scuttlebot Status\n────────────────────────────────────────\n';
+            statusText += `Enabled:     yes\n`;
+            statusText += `Nick:        ${sbStatus.nick}\n`;
+            statusText += `IRC:         ${sbStatus.config?.ircAddr}\n`;
+            statusText += `Channel:     #${sbStatus.config?.channel}\n`;
+            statusText += `Connected:   ${sbStatus.connected ? 'yes' : 'no'}`;
+            if (sbStatus.config?.channels && sbStatus.config.channels.length > 1) {
+                statusText += `\nChannels:    ${sbStatus.config.channels.map((c) => '#' + c).join(', ')}`;
+            }
+            statusText += '\n\nCommands:\n  /scuttlebot <message>  Post a message\n  /scuttlebot disable    Disable integration';
+            ctx.addMessage('system', statusText);
+            // Allow manual message posting
+            if (subCmd && subCmd !== 'enable' && subCmd !== 'disable') {
+                const message = parts.slice(1).join(' ');
+                scuttlebotClient.postMessage(message).then(() => {
+                    ctx.addMessage('system', 'Message posted to scuttlebot.');
+                }).catch((err) => {
+                    ctx.addMessage('system', `Failed to post message: ${err instanceof Error ? err.message : String(err)}`);
+                });
+            }
             break;
         }
         case '/config':
@@ -2646,19 +2739,234 @@ Example: /loop "Build a REST API" --max-iterations 50 --completion-promise "DONE
             }
             else if (subCmd === 'off') {
                 config.set('circuitBreakersEnabled', false);
-                ctx.addMessage('system', '\u2713 Circuit breakers disabled (will take effect on next agent run)');
+                // Also disable the current circuit breaker instance if it exists
+                if (ctx.circuitBreaker) {
+                    ctx.circuitBreaker = undefined;
+                    ctx.setBreakerHealth?.('ok');
+                }
+                ctx.addMessage('system', '\u2713 Circuit breakers disabled');
             }
             else if (subCmd === 'on') {
                 config.set('circuitBreakersEnabled', true);
                 ctx.addMessage('system', '\u2713 Circuit breakers enabled');
             }
+            else if (subCmd === 'adjust') {
+                const breakerTypeString = parts[2];
+                const param = parts[3];
+                const rawValue = parts[4];
+                // Handle special 'list' command to show detailed parameter info
+                if (breakerTypeString === 'list') {
+                    ctx.addMessage('system', `Circuit Breaker Configuration Reference:
+
+📊 REPEATED-FAILURE (Consecutive Errors)
+  • maxConsecutiveErrors: Number of consecutive errors before tripping (default: 3)
+  Example: /breaker adjust repeated-failure maxConsecutiveErrors 5
+
+💰 COST-RUNAWAY (Spending Control)
+  • maxSessionCost: Maximum total cost per session in USD (default: $5.0)
+  • maxCostPerMinute: Maximum spending rate per minute in USD (default: $1.0)
+  • windowSizeMs: Sliding window size for rate calculation in milliseconds (default: 60000)
+  Examples:
+    /breaker adjust cost-runaway maxSessionCost 10.0
+    /breaker adjust cost-runaway maxCostPerMinute 2.0
+
+🔄 INFINITE-LOOP (Repetitive Behavior)
+  • maxIdenticalInWindow: Max identical tool calls in window before tripping (default: 3)
+  • windowSize: Number of recent tool calls to analyze (default: 6)
+  • detectOscillation: Detect A-B-A-B oscillation patterns (default: true)
+  Examples:
+    /breaker adjust infinite-loop maxIdenticalInWindow 5
+    /breaker adjust infinite-loop detectOscillation false
+
+🔥 TOKEN-BURN (Token Usage Limits)
+  • maxTokensPerIteration: Max tokens per single iteration (default: 200,000)
+  • maxTotalTokens: Max total tokens per session (default: 5,000,000)
+  Examples:
+    /breaker adjust token-burn maxTokensPerIteration 100000
+    /breaker adjust token-burn maxTotalTokens 1000000
+
+⏸️  STALL (Progress Detection)
+  • maxIdleIterations: Max iterations with no tool calls/content (default: 5)
+  Example: /breaker adjust stall maxIdleIterations 3
+
+⏰ WALL-CLOCK (Time Limits)
+  • maxSessionDurationMs: Max session duration in milliseconds (0 = unlimited, default: 0)
+  • maxIterationDurationMs: Max single iteration duration in milliseconds (default: 600000 = 10 min)
+  Examples:
+    /breaker adjust wall-clock maxSessionDurationMs 3600000  # 1 hour
+    /breaker adjust wall-clock maxIterationDurationMs 300000  # 5 minutes
+
+Quick Commands:
+  /breaker adjust <type>              - Show current settings for that type
+  /breaker adjust                     - Show types overview
+  /breaker status                     - Show current breaker states`);
+                    break;
+                }
+                // Show basic types overview if no type specified
+                if (!breakerTypeString) {
+                    ctx.addMessage('system', `Circuit Breaker Types Available for Configuration:
+
+  repeated-failure  - Consecutive errors before tripping
+  cost-runaway      - Spending rate and total cost limits  
+  infinite-loop     - Identical tool calls and oscillation detection
+  token-burn        - Token usage per iteration and total limits
+  stall             - Idle iterations without progress
+  wall-clock        - Time-based session and iteration limits
+
+Usage: /breaker adjust <type> [param] [value]
+       /breaker adjust list                   - Show detailed parameter reference
+
+Examples:
+  /breaker adjust repeated-failure          - Show current settings
+  /breaker adjust cost-runaway maxSessionCost 10.0
+  /breaker adjust infinite-loop detectOscillation true`);
+                    break;
+                }
+                // Cast to BreakerType and validate
+                const breakerType = breakerTypeString;
+                const validTypes = ['repeated-failure', 'cost-runaway', 'infinite-loop', 'token-burn', 'stall', 'wall-clock'];
+                if (!validTypes.includes(breakerType)) {
+                    ctx.addMessage('error', `Invalid breaker type "${breakerType}". Valid types: ${validTypes.join(', ')}`);
+                    break;
+                }
+                const currentConfig = ctx.circuitBreaker.getConfig();
+                const breakerConfig = currentConfig.breakers[breakerType];
+                // Show current configuration if no param specified
+                if (!param) {
+                    let configDisplay = `${breakerType} Circuit Breaker Settings:\n`;
+                    switch (breakerType) {
+                        case 'repeated-failure':
+                            configDisplay += `  maxConsecutiveErrors: ${breakerConfig.maxConsecutiveErrors} errors\n\nUsage: /breaker adjust repeated-failure <param> <value>\n  /breaker adjust repeated-failure maxConsecutiveErrors <number>`;
+                            break;
+                        case 'cost-runaway':
+                            configDisplay += `  maxSessionCost: ${breakerConfig.maxSessionCost} per session\n  maxCostPerMinute: ${breakerConfig.maxCostPerMinute} per minute\n  windowSizeMs: ${breakerConfig.windowSizeMs}ms\n\nUsage: /breaker adjust cost-runaway <param> <value>\n  /breaker adjust cost-runaway maxSessionCost <dollars>\n  /breaker adjust cost-runaway maxCostPerMinute <dollars>\n  /breaker adjust cost-runaway windowSizeMs <milliseconds>`;
+                            break;
+                        case 'infinite-loop':
+                            configDisplay += `  maxIdenticalInWindow: ${breakerConfig.maxIdenticalInWindow} calls\n  windowSize: ${breakerConfig.windowSize} recent calls\n  detectOscillation: ${breakerConfig.detectOscillation}\n\nUsage: /breaker adjust infinite-loop <param> <value>\n  /breaker adjust infinite-loop maxIdenticalInWindow <number>\n  /breaker adjust infinite-loop windowSize <number>\n  /breaker adjust infinite-loop detectOscillation <true|false>`;
+                            break;
+                        case 'token-burn':
+                            configDisplay += `  maxTokensPerIteration: ${breakerConfig.maxTokensPerIteration.toLocaleString()} tokens\n  maxTotalTokens: ${breakerConfig.maxTotalTokens.toLocaleString()} tokens\n\nUsage: /breaker adjust token-burn <param> <value>\n  /breaker adjust token-burn maxTokensPerIteration <number>\n  /breaker adjust token-burn maxTotalTokens <number>`;
+                            break;
+                        case 'stall':
+                            configDisplay += `  maxIdleIterations: ${breakerConfig.maxIdleIterations} iterations\n\nUsage: /breaker adjust stall <param> <value>\n  /breaker adjust stall maxIdleIterations <number>`;
+                            break;
+                        case 'wall-clock':
+                            const sessionDuration = breakerConfig.maxSessionDurationMs;
+                            const iterationDuration = breakerConfig.maxIterationDurationMs;
+                            configDisplay += `  maxSessionDurationMs: ${sessionDuration === 0 ? 'unlimited' : sessionDuration + 'ms'}\n  maxIterationDurationMs: ${iterationDuration}ms (${Math.round(iterationDuration / 60000)} minutes)\n\nUsage: /breaker adjust wall-clock <param> <value>\n  /breaker adjust wall-clock maxSessionDurationMs <milliseconds>\n  /breaker adjust wall-clock maxIterationDurationMs <milliseconds>`;
+                            break;
+                    }
+                    ctx.addMessage('system', configDisplay);
+                    break;
+                }
+                // Parse and validate the value
+                let parsedValue;
+                // Handle boolean parameters
+                if (param === 'detectOscillation') {
+                    if (rawValue === 'true')
+                        parsedValue = true;
+                    else if (rawValue === 'false')
+                        parsedValue = false;
+                    else {
+                        ctx.addMessage('error', 'detectOscillation must be "true" or "false"');
+                        break;
+                    }
+                }
+                else {
+                    // Handle numeric parameters
+                    parsedValue = parseFloat(rawValue);
+                    if (isNaN(parsedValue) || parsedValue < 0) {
+                        ctx.addMessage('error', 'Value must be a non-negative number');
+                        break;
+                    }
+                }
+                // Validate parameter names for each breaker type
+                const paramValidations = {
+                    'repeated-failure': {
+                        params: ['maxConsecutiveErrors'],
+                        validate: (param, value) => value <= 0 ? 'maxConsecutiveErrors must be > 0' : null
+                    },
+                    'cost-runaway': {
+                        params: ['maxSessionCost', 'maxCostPerMinute', 'windowSizeMs'],
+                        validate: (param, value) => value <= 0 ? `${param} must be > 0` : null
+                    },
+                    'infinite-loop': {
+                        params: ['maxIdenticalInWindow', 'windowSize', 'detectOscillation'],
+                        validate: (param, value) => {
+                            if (param === 'detectOscillation')
+                                return null; // boolean is already validated above
+                            return value <= 0 ? `${param} must be > 0` : null;
+                        }
+                    },
+                    'token-burn': {
+                        params: ['maxTokensPerIteration', 'maxTotalTokens'],
+                        validate: (param, value) => value <= 0 ? `${param} must be > 0` : null
+                    },
+                    'stall': {
+                        params: ['maxIdleIterations'],
+                        validate: (param, value) => value <= 0 ? 'maxIdleIterations must be > 0' : null
+                    },
+                    'wall-clock': {
+                        params: ['maxSessionDurationMs', 'maxIterationDurationMs'],
+                        validate: (param, value) => {
+                            if (param === 'maxSessionDurationMs' && value === 0)
+                                return null; // 0 = unlimited is valid
+                            return value < 0 ? `${param} cannot be negative` : null;
+                        }
+                    }
+                };
+                const validation = paramValidations[breakerType];
+                if (!validation.params.includes(param)) {
+                    ctx.addMessage('error', `Invalid parameter "${param}" for ${breakerType}. Valid parameters: ${validation.params.join(', ')}`);
+                    break;
+                }
+                // Run custom validation if provided
+                if (validation.validate) {
+                    const error = validation.validate(param, parsedValue);
+                    if (error) {
+                        ctx.addMessage('error', error);
+                        break;
+                    }
+                }
+                // Update the configuration
+                const oldValue = breakerConfig[param];
+                ctx.circuitBreaker.adjust(breakerType, { [param]: parsedValue });
+                // Format the success message based on parameter type
+                let formattedOld, formattedNew;
+                if (param === 'detectOscillation') {
+                    formattedOld = String(oldValue);
+                    formattedNew = String(parsedValue);
+                }
+                else if (param.includes('Cost')) {
+                    formattedOld = `${oldValue}`;
+                    formattedNew = `${parsedValue}`;
+                }
+                else if (param.includes('Ms')) {
+                    formattedOld = oldValue === 0 ? 'unlimited' : `${oldValue}ms`;
+                    formattedNew = parsedValue === 0 ? 'unlimited' : `${parsedValue}ms`;
+                }
+                else if (param.includes('Tokens')) {
+                    formattedOld = oldValue.toLocaleString();
+                    formattedNew = parsedValue.toLocaleString();
+                }
+                else {
+                    formattedOld = String(oldValue);
+                    formattedNew = String(parsedValue);
+                }
+                ctx.addMessage('system', `✅ ${breakerType} ${param}: ${formattedOld} → ${formattedNew}`);
+            }
             else {
-                ctx.addMessage('system', `Usage: /breaker [status|resume|reset|on|off]
+                ctx.addMessage('system', `Usage: /breaker [status|resume|reset|adjust|on|off]
   /breaker resume [type]  - Resume tripped breaker (half-open)
   /breaker reset [type]   - Reset breaker to closed
+  /breaker adjust [type] [param] [value] - Configure breaker thresholds
   /breaker on|off         - Enable/disable circuit breakers
 
-Breaker types: repeated-failure, cost-runaway, infinite-loop, token-burn, stall`);
+Breaker types: repeated-failure, cost-runaway, infinite-loop, token-burn, stall, wall-clock
+
+Quick help:
+  /breaker adjust         - Show types overview
+  /breaker adjust list    - Show detailed parameter reference`);
             }
             break;
         }