@kernel.chat/kbot 3.8.1 → 3.9.0

package/dist/cli.js

@@ -20,7 +20,7 @@ import { clearHistory, clearMemory, compactHistory, restoreHistory } from './mem
 import { saveSession, loadSession, listSessions, deleteSession, formatSessionList, } from './sessions.js';
 import { createAgent, removeAgent, getAgent, formatAgentList, formatAgentDetail, PRESETS, getMatrixAgentIds, activateMimic, listMimicProfiles, getMimicProfile, registerBuiltinAgents, formatBuiltinAgentList, formatBuiltinAgentDetail, } from './matrix.js';
 import { getExtendedStats, incrementSessions, learnFact, selfTrain, getTrainingLog, flushPendingWrites } from './learning.js';
-import { banner, bannerCompact, bannerAuth, prompt as kbotPrompt, printError, printSuccess, printInfo, printResponse, printHelp, printGoodbye, setQuiet, } from './ui.js';
+import { banner, bannerCompact, bannerAuth, prompt as kbotPrompt, printError, printSuccess, printInfo, printWarn, printResponse, printHelp, printGoodbye, setQuiet, } from './ui.js';
 import { checkForUpdate, selfUpdate } from './updater.js';
 import { runTutorial } from './tutorial.js';
 import { syncOnStartup, schedulePush, flushCloudSync, isCloudSyncEnabled, setCloudToken, getCloudToken } from './cloud-sync.js';
@@ -46,6 +46,7 @@ async function main() {
         .option('-t, --thinking', 'Show AI reasoning steps')
         .option('--thinking-budget <tokens>', 'Thinking token budget (default: 10000)')
         .option('--self-eval', 'Enable self-evaluation loop (score and retry low-quality responses)')
+        .option('--plan', 'Plan mode — read-only exploration, no changes')
         .option('--architect', 'Architect mode — plan-review-implement with dual agents')
         .option('--safe', 'Confirm destructive operations')
         .option('--strict', 'Confirm ALL operations')
@@ -525,6 +526,161 @@ async function main() {
         const speed = system.recommendModelSpeed();
         process.stderr.write(`\n  ${AMETHYST('Cost regulation')}: ${speed === 'fast' ? chalk.yellow('conserving (fast model)') : chalk.green('normal (default model)')}\n\n`);
     });
+    program
+        .command('status')
+        .description('Unified Kernel dashboard — version, tools, agents, learning, collective, npm, GitHub, bootstrap')
+        .option('--json', 'Output as JSON')
+        .action(async (opts) => {
+        // Check both subcommand and parent opts (commander absorbs --json at parent level)
+        const jsonMode = opts.json || program.opts().json;
+        const chalk = (await import('chalk')).default;
+        const AMETHYST = chalk.hex('#6B5B95');
+        const DIM = chalk.dim;
+        const GREEN = chalk.hex('#4ADE80');
+        const YELLOW = chalk.hex('#FBBF24');
+        const RED = chalk.hex('#F87171');
+        const CYAN = chalk.hex('#67E8F9');
+        const line = DIM('  ' + '─'.repeat(40));
+        // ── 1. Version & latest check ──
+        let latestVersion = '';
+        let isLatest = false;
+        const npmDownloads = {};
+        const githubData = {};
+        // Fire all network requests in parallel with 3s timeouts
+        const [npmVersionRes, npmDlRes, ghRes] = await Promise.allSettled([
+            fetch('https://registry.npmjs.org/@kernel.chat/kbot/latest', { signal: AbortSignal.timeout(3000) })
+                .then(r => r.json()),
+            fetch('https://api.npmjs.org/downloads/point/last-week/@kernel.chat/kbot', { signal: AbortSignal.timeout(3000) })
+                .then(r => r.json()),
+            fetch('https://api.github.com/repos/isaacsight/kernel', { signal: AbortSignal.timeout(3000) })
+                .then(r => r.json()),
+        ]);
+        if (npmVersionRes.status === 'fulfilled' && npmVersionRes.value.version) {
+            latestVersion = npmVersionRes.value.version;
+            isLatest = VERSION === latestVersion;
+        }
+        if (npmDlRes.status === 'fulfilled' && npmDlRes.value.downloads !== undefined) {
+            npmDownloads.downloads = npmDlRes.value.downloads;
+        }
+        if (ghRes.status === 'fulfilled' && ghRes.value.stargazers_count !== undefined) {
+            githubData.stars = ghRes.value.stargazers_count;
+            githubData.issues = ghRes.value.open_issues_count ?? 0;
+        }
+        // ── 2. Learning stats ──
+        const { getStats } = await import('./learning.js');
+        const stats = getStats();
+        // ── 3. Collective ──
+        const { getOptInState } = await import('./collective.js');
+        const collectiveState = getOptInState();
+        // ── 4. Tools count ──
+        const { getAllTools } = await import('./tools/index.js');
+        const toolCount = getAllTools().length || 290; // fallback to known count if tools not yet registered
+        // ── 5. Bootstrap (autotelic score) ──
+        let bootstrapScore = 0;
+        let bootstrapMax = 0;
+        let bootstrapGrade = '?';
+        let bootstrapTopFix = '';
+        let distributionPct = '';
+        try {
+            const { runBootstrap } = await import('./bootstrap.js');
+            const report = await runBootstrap();
+            bootstrapScore = report.score;
+            bootstrapMax = report.maxScore;
+            bootstrapGrade = report.grade;
+            bootstrapTopFix = report.topFix;
+            const distSection = report.sections.find(s => s.name.toLowerCase().includes('distribution'));
+            if (distSection) {
+                distributionPct = `${Math.round((distSection.score / distSection.maxScore) * 100)}%`;
+            }
+        }
+        catch { /* bootstrap can fail if not in a project dir */ }
+        // ── 6. Cognitive modules — count from known list ──
+        const cognitiveModules = [
+            'learning', 'entropy-context', 'autopoiesis', 'free-energy',
+            'predictive-processing', 'reasoning', 'intentionality',
+            'temporal', 'confidence', 'strange-loops', 'integrated-information',
+        ];
+        const cognitiveCount = cognitiveModules.length; // 11
+        // ── JSON output ──
+        if (jsonMode) {
+            console.log(JSON.stringify({
+                version: VERSION,
+                latestVersion: latestVersion || null,
+                isLatest,
+                tools: toolCount,
+                agents: 23,
+                cognitiveModules: cognitiveCount,
+                learning: {
+                    patterns: stats.patternsCount,
+                    solutions: stats.solutionsCount,
+                    tokensSaved: stats.totalTokensSaved,
+                    efficiency: stats.efficiency,
+                },
+                collective: {
+                    enabled: collectiveState.enabled,
+                    signalsSent: collectiveState.total_signals_sent,
+                },
+                npm: { weeklyDownloads: npmDownloads.downloads ?? null },
+                github: { stars: githubData.stars ?? null, issues: githubData.issues ?? null },
+                bootstrap: {
+                    score: bootstrapScore,
+                    maxScore: bootstrapMax,
+                    grade: bootstrapGrade,
+                    topFix: bootstrapTopFix,
+                },
+            }, null, 2));
+            return;
+        }
+        // ── Formatted dashboard ──
+        const versionTag = latestVersion
+            ? (isLatest ? GREEN(' (latest ✓)') : YELLOW(` (update: ${latestVersion})`))
+            : DIM(' (offline)');
+        const fmtNum = (n) => n.toLocaleString();
+        process.stderr.write('\n');
+        process.stderr.write(`  ${AMETHYST('◉')} ${chalk.bold('Kernel Status')}\n`);
+        process.stderr.write(line + '\n');
+        process.stderr.write(`  ${chalk.bold('Version')}     ${VERSION}${versionTag}\n`);
+        process.stderr.write(`  ${chalk.bold('Tools')}       ${fmtNum(toolCount)} ${DIM('|')} ${chalk.bold('Agents')} 23\n`);
+        process.stderr.write(`  ${chalk.bold('Cognitive')}   ${cognitiveCount}/${cognitiveCount} modules active\n`);
+        process.stderr.write(line + '\n');
+        // Learning
+        const tokensSavedStr = stats.totalTokensSaved > 0 ? fmtNum(stats.totalTokensSaved) + ' tokens saved' : 'learning...';
+        process.stderr.write(`  ${chalk.bold('Learning')}    ${fmtNum(stats.patternsCount)} patterns ${DIM('|')} ${fmtNum(stats.solutionsCount)} solutions ${DIM('|')} ${tokensSavedStr}\n`);
+        // Collective
+        const collectiveEnabled = collectiveState.enabled ? GREEN('enabled') : DIM('disabled');
+        const signalsSent = fmtNum(collectiveState.total_signals_sent || 0);
+        process.stderr.write(`  ${chalk.bold('Collective')}  ${collectiveEnabled} ${DIM('|')} ${signalsSent} signals sent\n`);
+        process.stderr.write(line + '\n');
+        // npm
+        if (npmDownloads.downloads !== undefined) {
+            process.stderr.write(`  ${chalk.bold('npm')}         ${CYAN(fmtNum(npmDownloads.downloads))} downloads/week\n`);
+        }
+        else {
+            process.stderr.write(`  ${chalk.bold('npm')}         ${DIM('unavailable')}\n`);
+        }
+        // GitHub
+        if (githubData.stars !== undefined) {
+            const starStr = `${fmtNum(githubData.stars)} star${githubData.stars === 1 ? '' : 's'}`;
+            const issueStr = `${fmtNum(githubData.issues)} issue${githubData.issues === 1 ? '' : 's'}`;
+            process.stderr.write(`  ${chalk.bold('GitHub')}      ${starStr} ${DIM('|')} ${issueStr}\n`);
+        }
+        else {
+            process.stderr.write(`  ${chalk.bold('GitHub')}      ${DIM('unavailable')}\n`);
+        }
+        // Bootstrap
+        if (bootstrapMax > 0) {
+            const pct = Math.round((bootstrapScore / bootstrapMax) * 100);
+            const gradeColor = pct >= 80 ? GREEN : pct >= 60 ? YELLOW : RED;
+            const distStr = distributionPct ? ` ${DIM('— distribution at')} ${distributionPct}` : '';
+            process.stderr.write(`  ${chalk.bold('Bootstrap')}   ${bootstrapScore}/${bootstrapMax} (${gradeColor(bootstrapGrade)})${distStr}\n`);
+        }
+        process.stderr.write(line + '\n');
+        // Next action (top fix from bootstrap)
+        if (bootstrapTopFix) {
+            process.stderr.write(`  ${chalk.bold('Next:')} ${bootstrapTopFix}\n`);
+        }
+        process.stderr.write('\n');
+    });
     program
         .command('immune')
         .description('Self-audit — kbot\'s immune system scans its own code for bugs, security holes, and bad decisions')
@@ -600,8 +756,10 @@ async function main() {
         .option('--disable', 'Opt out of collective learning')
         .option('--status', 'Show collective learning status')
         .option('--pull', 'Pull latest collective patterns')
+        .option('--diagnose', 'Run end-to-end health check on collective connectivity')
+        .option('--insights', 'Show what the collective knows (hints table + top patterns)')
         .action(async (opts) => {
-        const { setOptIn, getCollectiveStats, pullCollectiveHints, pullCollectivePatterns, getOptInState } = await import('./collective.js');
+        const { setOptIn, getCollectiveStats, pullCollectiveHints, pullCollectivePatterns, getOptInState, sendSignal, getSignalQueueSize } = await import('./collective.js');
         if (opts.enable) {
             setOptIn(true);
             printSuccess('Collective learning enabled!');
@@ -620,6 +778,146 @@ async function main() {
             printSuccess(`Pulled ${hints.length} routing hints and ${patterns.length} patterns from the collective.`);
             return;
         }
+        if (opts.diagnose) {
+            console.log();
+            printInfo('Collective Health Check');
+            printInfo('─'.repeat(40));
+            // 1. Opt-in status
+            const state = getOptInState();
+            if (state.enabled) {
+                printSuccess(`Opt-in: enabled (since ${state.opted_in_at || 'unknown'})`);
+            }
+            else {
+                printWarn('Opt-in: disabled — enable with `kbot collective --enable`');
+            }
+            // 2. Test signal
+            printInfo('Sending test signal...');
+            // Temporarily need opt-in for sendSignal to work
+            const wasEnabled = state.enabled;
+            if (!wasEnabled)
+                setOptIn(true);
+            const testSignal = {
+                message_hash: 'test',
+                message_category: 'diagnostic',
+                message_length: 4,
+                routed_agent: 'kernel',
+                classifier_confidence: 1.0,
+                was_rerouted: false,
+                response_quality: 1.0,
+                tool_sequence: ['diagnostic_ping'],
+                strategy: 'health_check',
+                source: 'kbot',
+            };
+            const signalOk = await sendSignal(testSignal);
+            if (!wasEnabled)
+                setOptIn(false); // Restore original state
+            if (signalOk) {
+                printSuccess('Signal send: OK — endpoint accepted the test signal');
+            }
+            else {
+                printError('Signal send: FAILED — endpoint unreachable or rejected the signal');
+            }
+            // 3. Pull hints
+            printInfo('Pulling routing hints...');
+            try {
+                const hints = await pullCollectiveHints();
+                if (hints.length > 0) {
+                    printSuccess(`Hints pull: OK — ${hints.length} routing hints available`);
+                }
+                else {
+                    printWarn('Hints pull: empty — no routing hints available yet');
+                }
+            }
+            catch {
+                printError('Hints pull: FAILED — could not retrieve hints');
+            }
+            // 4. Pull patterns
+            printInfo('Pulling collective patterns...');
+            try {
+                const patterns = await pullCollectivePatterns();
+                if (patterns.length > 0) {
+                    printSuccess(`Patterns pull: OK — ${patterns.length} patterns available`);
+                }
+                else {
+                    printWarn('Patterns pull: empty — no patterns available yet');
+                }
+            }
+            catch {
+                printError('Patterns pull: FAILED — could not retrieve patterns');
+            }
+            // 5. Signal queue status
+            const queueSize = getSignalQueueSize();
+            if (queueSize === 0) {
+                printSuccess('Signal queue: empty (all signals flushed)');
+            }
+            else {
+                printInfo(`Signal queue: ${queueSize} signal(s) pending flush`);
+            }
+            // Summary
+            console.log();
+            printInfo(`Total signals sent: ${state.total_signals_sent}`);
+            printInfo(`Last signal: ${state.last_signal_at || 'never'}`);
+            console.log();
+            return;
+        }
+        if (opts.insights) {
+            console.log();
+            printInfo('Collective Intelligence Insights');
+            printInfo('═'.repeat(50));
+            // Pull fresh data
+            const [hints, patterns] = await Promise.all([pullCollectiveHints(), pullCollectivePatterns()]);
+            // Routing hints table
+            console.log();
+            printInfo('Routing Hints');
+            printInfo('─'.repeat(50));
+            if (hints.length === 0) {
+                printWarn('No routing hints available yet. The collective needs more signals.');
+            }
+            else {
+                // Table header
+                const catW = 18, agentW = 14, confW = 12, sampW = 8;
+                console.log(chalk.bold('  ' +
+                    'Category'.padEnd(catW) +
+                    'Best Agent'.padEnd(agentW) +
+                    'Confidence'.padEnd(confW) +
+                    'Samples'.padEnd(sampW)));
+                console.log('  ' + '─'.repeat(catW + agentW + confW + sampW));
+                for (const h of hints) {
+                    const conf = (h.confidence * 100).toFixed(0) + '%';
+                    console.log('  ' +
+                        h.category.padEnd(catW) +
+                        h.best_agent.padEnd(agentW) +
+                        conf.padEnd(confW) +
+                        String(h.sample_count).padEnd(sampW));
+                }
+            }
+            // Top tool-sequence patterns
+            console.log();
+            printInfo('Top Tool Sequences');
+            printInfo('─'.repeat(50));
+            const toolPatterns = patterns
+                .filter(p => p.type === 'tool_sequence')
+                .sort((a, b) => b.confidence - a.confidence || b.sample_count - a.sample_count)
+                .slice(0, 10);
+            if (toolPatterns.length === 0) {
+                printWarn('No tool-sequence patterns available yet.');
+            }
+            else {
+                for (let i = 0; i < toolPatterns.length; i++) {
+                    const p = toolPatterns[i];
+                    const pat = p.pattern;
+                    const tools = Array.isArray(pat.tools) ? pat.tools.join(' → ') : 'unknown';
+                    const category = typeof pat.category === 'string' ? pat.category : 'general';
+                    const conf = (p.confidence * 100).toFixed(0) + '%';
+                    console.log(chalk.dim(`  ${String(i + 1).padStart(2)}.`) +
+                        ` [${category}] ` +
+                        chalk.cyan(tools) +
+                        chalk.dim(` (${conf}, ${p.sample_count} samples)`));
+                }
+            }
+            console.log();
+            return;
+        }
         // Default: show status
         console.log();
         console.log(getCollectiveStats());
@@ -1001,6 +1299,113 @@ async function main() {
         const md = generateChangelog({ since: changelogOpts.since, format: 'markdown' });
         process.stdout.write(md);
     });
+    // ── Automate subcommands ──
+    const automateCmd = program
+        .command('automate')
+        .description('Event-driven automations — file watchers, schedules, git hooks, webhooks');
+    automateCmd
+        .command('list')
+        .description('List all configured automations')
+        .action(async () => {
+        const { listAutomations, formatAutomationList } = await import('./automations.js');
+        const automations = listAutomations();
+        process.stderr.write(formatAutomationList(automations) + '\n');
+    });
+    automateCmd
+        .command('add')
+        .description('Create a new automation')
+        .requiredOption('--trigger <trigger>', 'Trigger spec (e.g., "file:src/**/*.ts:change", "schedule:every 5m", "git:pre-commit", "webhook:/deploy")')
+        .requiredOption('--agent <agent>', 'Agent to run (e.g., coder, researcher, guardian)')
+        .requiredOption('--prompt <prompt>', 'Prompt to send to the agent')
+        .option('--name <name>', 'Human-readable name for the automation')
+        .option('--tools <tools>', 'Comma-separated list of tools to enable')
+        .action(async (addOpts) => {
+        try {
+            const { createAutomation, parseTriggerString } = await import('./automations.js');
+            const trigger = parseTriggerString(addOpts.trigger);
+            const automation = createAutomation({
+                name: addOpts.name || `${trigger.type}:${addOpts.agent}`,
+                trigger,
+                action: {
+                    agent: addOpts.agent,
+                    prompt: addOpts.prompt,
+                    tools: addOpts.tools ? addOpts.tools.split(',').map((t) => t.trim()) : undefined,
+                },
+            });
+            printSuccess(`Automation created: ${automation.name} (${automation.id})`);
+            printInfo(`  Trigger: ${addOpts.trigger}`);
+            printInfo(`  Agent: ${addOpts.agent}`);
+            if (trigger.type === 'git') {
+                printInfo('  Git hooks installed.');
+            }
+            if (trigger.type === 'file' || trigger.type === 'schedule') {
+                printInfo('  Run `kbot automate start` to activate the daemon.');
+            }
+        }
+        catch (err) {
+            printError(err instanceof Error ? err.message : String(err));
+            process.exit(1);
+        }
+    });
+    automateCmd
+        .command('remove')
+        .description('Remove an automation by ID')
+        .argument('<id>', 'Automation ID')
+        .action(async (id) => {
+        const { removeAutomation } = await import('./automations.js');
+        const removed = removeAutomation(id);
+        if (removed) {
+            printSuccess(`Automation "${id}" removed.`);
+        }
+        else {
+            printError(`Automation "${id}" not found.`);
+            process.exit(1);
+        }
+    });
+    automateCmd
+        .command('run')
+        .description('Manually trigger an automation')
+        .argument('<id>', 'Automation ID')
+        .action(async (id) => {
+        const { runAutomation, getAutomation } = await import('./automations.js');
+        const automation = getAutomation(id);
+        if (!automation) {
+            printError(`Automation "${id}" not found.`);
+            process.exit(1);
+        }
+        printInfo(`Running automation: ${automation.name}...`);
+        const result = await runAutomation(id);
+        if (result.success) {
+            printSuccess(`Automation completed successfully.`);
+            if (result.output) {
+                process.stderr.write('\n' + result.output + '\n');
+            }
+        }
+        else {
+            printError(`Automation failed: ${result.error}`);
+            process.exit(1);
+        }
+    });
+    automateCmd
+        .command('start')
+        .description('Start the automation daemon (file watchers + schedule timers)')
+        .action(async () => {
+        const { startAutomationDaemon, listAutomations } = await import('./automations.js');
+        const automations = listAutomations();
+        if (automations.length === 0) {
+            printError('No automations configured. Use `kbot automate add` first.');
+            process.exit(1);
+        }
+        printInfo('Starting automation daemon...');
+        const { running } = startAutomationDaemon({
+            log: (msg) => process.stderr.write(msg + '\n'),
+        });
+        if (running) {
+            printSuccess('Daemon running. Press Ctrl+C to stop.');
+            // Keep the process alive
+            await new Promise(() => { });
+        }
+    });
     program
         .command('completions')
         .description('Generate shell tab-completion script (bash, zsh, fish)')
@@ -1021,7 +1426,7 @@ async function main() {
     if (opts.quiet)
         setQuiet(true);
     // If a sub-command was run, we're done
-    if (['byok', 'auth', 'ide', 'local', 'ollama', 'kbot-local', 'pull', 'doctor', 'serve', 'agents', 'watch', 'voice', 'export', 'plugins', 'changelog', 'completions'].includes(program.args[0]))
+    if (['byok', 'auth', 'ide', 'local', 'ollama', 'kbot-local', 'pull', 'doctor', 'serve', 'agents', 'watch', 'voice', 'export', 'plugins', 'changelog', 'completions', 'automate', 'status'].includes(program.args[0]))
         return;
     // Check for API key (BYOK or local provider)
     let byokActive = isByokEnabled();
@@ -1215,6 +1620,7 @@ async function main() {
         tier,
         thinking: opts.thinking || false,
         thinkingBudget: opts.thinkingBudget ? (parseInt(opts.thinkingBudget, 10) || 10000) : undefined,
+        plan: opts.plan || false,
     };
     // Enable self-evaluation if requested
     if (opts.selfEval) {
@@ -1728,6 +2134,17 @@ async function startRepl(agentOpts, context, tier, byokActive = false, localActi
         }
         console.log(chalk.dim('  └─────────────────────────────────────────────────┘'));
         console.log();
+        // First-run collective learning nudge
+        try {
+            const { isCollectiveEnabled } = await import('./collective.js');
+            if (!isCollectiveEnabled()) {
+                printInfo('Join 4,000+ developers making kbot smarter for everyone:');
+                printInfo('  kbot collective --enable');
+                printInfo('  (anonymized — never shares code, files, or identity)');
+                console.log();
+            }
+        }
+        catch { /* collective module not available — skip silently */ }
     }
     else if (sessionCount <= 5) {
         // Sessions 2-5: rotate useful tips they might not know