@build-astron-co/nimbus 0.2.0 → 0.4.0

package/dist/src/commands/resume.js

@@ -0,0 +1,35 @@
+/**
+ * Resume Command
+ * Resume a Nimbus session by ID (or last session if omitted).
+ * Looks up sessions from SQLite, then launches chat with that session.
+ */
+import { ui } from '../wizard/ui';
+import { SessionManager } from '../sessions/manager';
+export async function resumeCommand(taskIdOrOptions = {}) {
+    const taskId = typeof taskIdOrOptions === 'string' ? taskIdOrOptions : taskIdOrOptions.taskId;
+    ui.header('Resume Session');
+    const sessionManager = SessionManager.getInstance();
+    // If no taskId given, try to resume the most recent session
+    if (!taskId) {
+        const sessions = sessionManager.list();
+        if (sessions.length === 0) {
+            ui.error('No sessions found. Start a new session with "nimbus chat".');
+            process.exit(1);
+        }
+        const lastSession = sessions[0];
+        ui.info(`Resuming last session: ${lastSession.id.slice(0, 8)}`);
+        const { chatCommand } = await import('./chat');
+        await chatCommand({ continue: true });
+        return;
+    }
+    // Look up specific session by ID (or prefix)
+    const sessions = sessionManager.list();
+    const found = sessions.find((s) => s.id === taskId || s.id.startsWith(taskId));
+    if (!found) {
+        ui.error(`Session not found. Use "nimbus sessions" to list available sessions.`);
+        process.exit(1);
+    }
+    ui.info(`Resuming session: ${found.id.slice(0, 8)}`);
+    const { chatCommand } = await import('./chat');
+    await chatCommand({ continue: true });
+}

package/dist/src/commands/rollback.js

@@ -0,0 +1,259 @@
+/**
+ * nimbus rollback — Infrastructure Rollback Assistant
+ *
+ * Provides guided rollback for Helm releases and Kubernetes deployments.
+ * For Terraform, explains the rollback approach via state management.
+ *
+ * G20: New command added to the gap fix plan.
+ *
+ * Usage:
+ *   nimbus rollback --helm <release>
+ *   nimbus rollback --helm <release> --namespace <ns>
+ *   nimbus rollback --k8s <deployment>
+ *   nimbus rollback --k8s <deployment> --namespace <ns>
+ *   nimbus rollback --tf
+ */
+import { ui, confirm, select } from '../wizard';
+/**
+ * Run the nimbus rollback command.
+ */
+export async function rollbackCommand(options) {
+    const { execFileSync } = await import('node:child_process');
+    const run = (cmd, args) => {
+        return execFileSync(cmd, args, {
+            encoding: 'utf-8',
+            timeout: 30000,
+            stdio: ['pipe', 'pipe', 'pipe'],
+        });
+    };
+    // Helm rollback
+    if (options.helm) {
+        await rollbackHelm(options.helm, options.namespace, run);
+        return;
+    }
+    // Kubernetes deployment rollback
+    if (options.k8s) {
+        await rollbackK8s(options.k8s, options.namespace, run);
+        return;
+    }
+    // Terraform state rollback (--terraform flag)
+    if (options.terraform) {
+        await rollbackTerraformState(options.tfDir ?? process.cwd(), run);
+        return;
+    }
+    // Terraform guidance (--tf flag)
+    if (options.tf) {
+        rollbackTerraformGuidance();
+        return;
+    }
+    ui.error('Specify a rollback target: --helm <release>, --k8s <deployment>, --tf, or --terraform');
+    ui.print('Usage:');
+    ui.print('  nimbus rollback --helm <release> [--namespace <ns>]');
+    ui.print('  nimbus rollback --k8s <deployment> [--namespace <ns>]');
+    ui.print('  nimbus rollback --tf');
+    ui.print('  nimbus rollback --terraform [--tf-dir <path>]');
+}
+async function rollbackHelm(release, namespace, run) {
+    const nsArgs = namespace ? ['--namespace', namespace] : [];
+    ui.info(`Fetching history for Helm release: ${release}`);
+    let historyOutput;
+    try {
+        historyOutput = run('helm', ['history', release, '--output', 'table', ...nsArgs]);
+    }
+    catch (e) {
+        const msg = e instanceof Error ? e.message : String(e);
+        ui.error(`Failed to fetch Helm history: ${msg}`);
+        return;
+    }
+    ui.newLine();
+    ui.print(historyOutput);
+    ui.newLine();
+    // Parse revision numbers from history output
+    const revisionLines = historyOutput
+        .split('\n')
+        .slice(1) // skip header
+        .filter(line => /^\d+/.test(line.trim()));
+    if (revisionLines.length === 0) {
+        ui.warning('No revision history found.');
+        return;
+    }
+    const revisionOptions = revisionLines.map(line => {
+        const parts = line.trim().split(/\s+/);
+        const rev = parts[0];
+        const status = parts[2] ?? '';
+        const description = parts.slice(4).join(' ') ?? '';
+        return {
+            value: rev,
+            label: `Revision ${rev} — ${status} ${description}`.trim(),
+        };
+    });
+    const selectedRevision = await select({
+        message: `Roll back ${release} to which revision?`,
+        options: revisionOptions,
+    });
+    if (!selectedRevision) {
+        ui.info('Rollback cancelled.');
+        return;
+    }
+    const confirmed = await confirm({
+        message: `Roll back ${release} to revision ${selectedRevision}? This will update the release.`,
+        defaultValue: false,
+    });
+    if (!confirmed) {
+        ui.info('Rollback cancelled.');
+        return;
+    }
+    ui.startSpinner({ message: `Rolling back ${release} to revision ${selectedRevision}...` });
+    try {
+        run('helm', ['rollback', release, selectedRevision, ...nsArgs]);
+        ui.stopSpinnerSuccess(`${release} rolled back to revision ${selectedRevision}`);
+    }
+    catch (e) {
+        const msg = e instanceof Error ? e.message : String(e);
+        ui.stopSpinnerFail(`Rollback failed: ${msg}`);
+    }
+}
+async function rollbackK8s(deployment, namespace, run) {
+    const nsArgs = namespace ? ['-n', namespace] : [];
+    const deployTarget = `deployment/${deployment}`;
+    ui.info(`Fetching rollout history for ${deployTarget}`);
+    let historyOutput;
+    try {
+        historyOutput = run('kubectl', ['rollout', 'history', deployTarget, ...nsArgs]);
+    }
+    catch (e) {
+        const msg = e instanceof Error ? e.message : String(e);
+        ui.error(`Failed to fetch rollout history: ${msg}`);
+        return;
+    }
+    ui.newLine();
+    ui.print(historyOutput);
+    ui.newLine();
+    const confirmed = await confirm({
+        message: `Undo the last rollout for ${deployTarget}? This will revert to the previous revision.`,
+        defaultValue: false,
+    });
+    if (!confirmed) {
+        ui.info('Rollback cancelled.');
+        return;
+    }
+    ui.startSpinner({ message: `Rolling back ${deployTarget}...` });
+    try {
+        run('kubectl', ['rollout', 'undo', deployTarget, ...nsArgs]);
+        ui.stopSpinnerSuccess(`${deployTarget} rolled back`);
+        // Show status
+        const status = run('kubectl', ['rollout', 'status', deployTarget, ...nsArgs]);
+        ui.print(status);
+    }
+    catch (e) {
+        const msg = e instanceof Error ? e.message : String(e);
+        ui.stopSpinnerFail(`Rollback failed: ${msg}`);
+    }
+}
+async function rollbackTerraformState(dir, run) {
+    const { existsSync, readdirSync } = await import('node:fs');
+    // Detect if terraform directory exists (look for *.tf files)
+    let hasTfFiles = false;
+    try {
+        hasTfFiles = existsSync(dir) && readdirSync(dir).some(f => f.endsWith('.tf'));
+    }
+    catch {
+        /* ignore */
+    }
+    if (!hasTfFiles) {
+        ui.warning(`No *.tf files found in ${dir}. Is this a Terraform directory?`);
+        ui.dim('Use --tf-dir <path> to specify a different directory.');
+        return;
+    }
+    // Show current workspace
+    let currentWorkspace = 'default';
+    try {
+        currentWorkspace = run('terraform', ['workspace', 'show']).trim();
+        ui.info(`Current Terraform workspace: ${currentWorkspace}`);
+    }
+    catch {
+        ui.dim('Could not determine current workspace (terraform not in PATH?)');
+    }
+    ui.newLine();
+    // Show state list
+    let stateList = '';
+    try {
+        stateList = run('terraform', ['state', 'list']).trim();
+    }
+    catch (e) {
+        const msg = e instanceof Error ? e.message : String(e);
+        ui.warning(`Could not list terraform state: ${msg}`);
+    }
+    if (stateList) {
+        ui.info('Current state resources:');
+        for (const line of stateList.split('\n').slice(0, 20)) {
+            ui.print(`  ${line}`);
+        }
+        const total = stateList.split('\n').length;
+        if (total > 20)
+            ui.dim(`  ... and ${total - 20} more`);
+        ui.newLine();
+    }
+    // Rollback guidance specific to state
+    ui.box({
+        title: `Terraform State Rollback — workspace: ${currentWorkspace}`,
+        content: [
+            '',
+            'To roll back Terraform state in workspace "' + currentWorkspace + '":',
+            '',
+            '1. Pull current state:',
+            '     terraform state pull > state-backup.tfstate',
+            '',
+            '2. Push a previous state backup:',
+            '     terraform state push <backup>.tfstate',
+            '',
+            '3. Or revert IaC code and re-apply:',
+            '     git checkout <commit> -- *.tf',
+            '     terraform plan && terraform apply',
+            '',
+            '4. For targeted resource rollback:',
+            '     terraform apply -target=<resource>',
+            '',
+            'Run `nimbus chat` for AI-assisted rollback guidance.',
+            '',
+        ],
+        style: 'rounded',
+        borderColor: 'yellow',
+        padding: 0,
+    });
+    ui.newLine();
+}
+function rollbackTerraformGuidance() {
+    ui.newLine();
+    ui.box({
+        title: 'Terraform Rollback Guidance',
+        content: [
+            '',
+            'Terraform does not have a built-in rollback command.',
+            'To restore previous infrastructure state, use one of these approaches:',
+            '',
+            '1. Revert IaC code to a previous git commit:',
+            '     git checkout <commit> -- *.tf',
+            '     terraform plan && terraform apply',
+            '',
+            '2. Restore state from a backup:',
+            '     terraform state pull > current.tfstate',
+            '     terraform state push <backup>.tfstate',
+            '',
+            '3. Use workspace-specific state:',
+            '     terraform workspace select <env>',
+            '     terraform state list',
+            '',
+            '4. Target a specific resource for rollback:',
+            '     terraform apply -target=<resource>',
+            '',
+            'Run `nimbus chat` to get AI-assisted rollback guidance.',
+            '',
+        ],
+        style: 'rounded',
+        borderColor: 'yellow',
+        padding: 0,
+    });
+    ui.newLine();
+}
+export default rollbackCommand;

package/dist/src/commands/rollout.js

@@ -0,0 +1,74 @@
+/**
+ * nimbus rollout — Watch Kubernetes Deployment Rollouts
+ *
+ * Streams real-time rollout status for a Kubernetes deployment.
+ * Wraps `kubectl rollout status deployment/<name> --watch`.
+ *
+ * L1: New command for DevOps parity.
+ *
+ * Usage:
+ *   nimbus rollout <deployment>
+ *   nimbus rollout <deployment> --namespace <ns>
+ *   nimbus rollout <deployment> --timeout 10m
+ */
+import { spawnExec } from '../tools/spawn-exec';
+/**
+ * Run the nimbus rollout command.
+ * Streams kubectl rollout status with live output.
+ */
+export async function rolloutCommand(options) {
+    const { deployment, namespace, timeout = '5m' } = options;
+    const nsFlag = namespace ? `-n ${namespace}` : '';
+    const timeoutFlag = `--timeout=${timeout}`;
+    const command = `kubectl rollout status deployment/${deployment} ${nsFlag} ${timeoutFlag} --watch`.trim().replace(/\s+/g, ' ');
+    console.log(`Watching rollout: deployment/${deployment}${namespace ? ` (namespace: ${namespace})` : ''}`);
+    console.log(`Timeout: ${timeout}\n`);
+    const ac = new AbortController();
+    // Allow Ctrl+C to gracefully abort the rollout watch
+    process.on('SIGINT', () => {
+        console.log('\nRollout watch interrupted.');
+        ac.abort();
+    });
+    try {
+        const result = await spawnExec(command, {
+            onChunk: (chunk) => {
+                process.stdout.write(chunk);
+            },
+            timeout: parseTimeoutToMs(timeout),
+        });
+        const combined = [result.stdout, result.stderr].filter(Boolean).join('\n');
+        if (result.exitCode !== 0) {
+            console.error(`\nRollout failed (exit code ${result.exitCode}):`);
+            if (combined)
+                console.error(combined);
+            process.exitCode = 1;
+        }
+        else {
+            console.log('\nRollout complete.');
+        }
+    }
+    catch (err) {
+        if (err.message?.includes('aborted')) {
+            // Already printed abort message
+        }
+        else {
+            console.error(`Rollout watch error: ${err instanceof Error ? err.message : String(err)}`);
+            process.exitCode = 1;
+        }
+    }
+}
+/**
+ * Parse a kubectl-style timeout string (e.g. "5m", "30s", "2h") to milliseconds.
+ */
+export function parseTimeoutToMs(timeout) {
+    const match = timeout.match(/^(\d+)(s|m|h)$/);
+    if (!match)
+        return 300_000; // default 5 min
+    const value = parseInt(match[1]);
+    switch (match[2]) {
+        case 's': return value * 1000;
+        case 'm': return value * 60 * 1000;
+        case 'h': return value * 3600 * 1000;
+        default: return 300_000;
+    }
+}

package/dist/src/commands/runbook.js

@@ -0,0 +1,307 @@
+/**
+ * Runbook Command (G15)
+ *
+ * Load and execute operational runbooks as agent prompts.
+ *
+ * Runbook YAML format:
+ *   name: rotate-certs
+ *   description: Rotate TLS certs in prod namespace
+ *   context: prod  # profile to activate
+ *   steps:
+ *     - Check for expiring certs in all namespaces
+ *     - Rotate each cert using cert-manager annotate
+ *     - Verify new certs are valid and pods restarted
+ *
+ * Usage:
+ *   nimbus runbook list
+ *   nimbus runbook run <name> [--auto]
+ *   nimbus runbook create <name>
+ */
+import { existsSync, readdirSync, readFileSync, writeFileSync, mkdirSync } from 'node:fs';
+import { join, basename } from 'node:path';
+import { homedir } from 'node:os';
+// ---------------------------------------------------------------------------
+// Helpers
+// ---------------------------------------------------------------------------
+/** Directories to scan for runbooks. */
+const RUNBOOK_DIRS = [
+    join(homedir(), '.nimbus', 'runbooks'),
+    join(process.cwd(), 'runbooks'),
+    join(process.cwd(), 'docs', 'runbooks'),
+    join(process.cwd(), '.github', 'runbooks'),
+];
+/**
+ * Find all runbook YAML files in the standard directories.
+ */
+function findRunbooks() {
+    const results = [];
+    for (const dir of RUNBOOK_DIRS) {
+        if (!existsSync(dir))
+            continue;
+        try {
+            const files = readdirSync(dir).filter(f => /\.(yaml|yml)$/.test(f));
+            for (const file of files) {
+                results.push({ path: join(dir, file), dir, file });
+            }
+        }
+        catch { /* non-critical */ }
+    }
+    return results;
+}
+/**
+ * Minimal YAML parser for simple runbook format (no external dep).
+ * Supports both plain string steps and structured steps with if:/require_approval: fields.
+ *
+ * Structured step example:
+ *   steps:
+ *     - name: Check certs
+ *       run: Check for expiring certs
+ *       if: cert_count > 0
+ *       require_approval: true
+ */
+function parseRunbookYaml(content) {
+    const lines = content.split('\n');
+    const def = { name: '', steps: [] };
+    let inSteps = false;
+    // We parse in two modes: simple (step is a plain `- text` line) and
+    // structured (step is a YAML mapping started by `- name:` or `- run:`).
+    let currentStep = null;
+    const flushStep = () => {
+        if (currentStep) {
+            def.steps.push(currentStep);
+            currentStep = null;
+        }
+    };
+    for (const raw of lines) {
+        const line = raw.trimEnd();
+        if (line.startsWith('#') || !line.trim())
+            continue;
+        if (line.startsWith('name:') && !inSteps) {
+            def.name = line.slice(5).trim().replace(/^['"]|['"]$/g, '');
+        }
+        else if (line.startsWith('description:') && !inSteps) {
+            def.description = line.slice(12).trim().replace(/^['"]|['"]$/g, '');
+        }
+        else if (line.startsWith('context:') && !inSteps) {
+            def.context = line.slice(8).trim().replace(/^['"]|['"]$/g, '');
+        }
+        else if (line.trim() === 'steps:') {
+            inSteps = true;
+        }
+        else if (inSteps) {
+            // Top-level step item: starts with exactly two spaces + "- "
+            if (/^ {0,2}- /.test(line)) {
+                flushStep();
+                const stepText = line.replace(/^\s*-\s*/, '').trim();
+                // Detect structured step: starts with "name:", "run:", "action:"
+                if (/^(name|run|action):/.test(stepText)) {
+                    const val = stepText.replace(/^(name|run|action):\s*/, '').replace(/^['"]|['"]$/g, '');
+                    currentStep = { text: val };
+                }
+                else if (stepText === '') {
+                    // blank mapping start — next indented lines fill it in
+                    currentStep = { text: '' };
+                }
+                else {
+                    // Plain string step
+                    def.steps.push({ text: stepText.replace(/^['"]|['"]$/g, '') });
+                }
+            }
+            else if (currentStep && /^\s+(name|run|action):/.test(line)) {
+                // Structured field continuation inside a step block
+                const val = line.replace(/^\s+(name|run|action):\s*/, '').replace(/^['"]|['"]$/g, '');
+                if (!currentStep.text)
+                    currentStep.text = val;
+            }
+            else if (currentStep && /^\s+if:/.test(line)) {
+                const val = line.replace(/^\s+if:\s*/, '').replace(/^['"]|['"]$/g, '');
+                currentStep.if = val;
+            }
+            else if (currentStep && /^\s+require_approval:/.test(line)) {
+                const val = line.replace(/^\s+require_approval:\s*/, '').trim();
+                currentStep.require_approval = val === 'true';
+            }
+            else if (!/^\s/.test(line)) {
+                // Non-indented non-step line — exit step parsing
+                flushStep();
+                inSteps = false;
+            }
+        }
+    }
+    flushStep();
+    return def;
+}
+/**
+ * Build a multi-step agent prompt from a runbook definition.
+ * Supports GAP-24 conditional steps (if:) and approval gates (require_approval:).
+ */
+function buildRunbookPrompt(def) {
+    const parts = [
+        `# Runbook: ${def.name}`,
+    ];
+    if (def.description)
+        parts.push(`\n${def.description}`);
+    if (def.context)
+        parts.push(`\nContext/profile: ${def.context}`);
+    parts.push('\n## Steps to execute in order:');
+    def.steps.forEach((step, i) => {
+        // GAP-24: In step parsing loop
+        const ifCondition = step.if;
+        const requireApproval = step.require_approval;
+        let stepText = `Step ${i + 1}: ${step.text}`;
+        if (ifCondition) {
+            stepText += `\n  [CONDITIONAL: Only proceed if: ${ifCondition}]`;
+            stepText += `\nAfter completing this step, check: ${ifCondition}. If the condition evaluates to false, stop and report the status without continuing to the next step.`;
+        }
+        if (requireApproval) {
+            stepText += `\n  [REQUIRES APPROVAL: State this step's plan and wait for explicit user approval before executing]`;
+            stepText = `IMPORTANT: Before executing this step, explicitly state what you are about to do and wait for the user to say "approve" or "yes" before proceeding.\n` + stepText;
+        }
+        parts.push(stepText);
+    });
+    parts.push('\nExecute each step in sequence. Check for errors after each step before proceeding. Report progress clearly.');
+    return parts.join('\n');
+}
+// ---------------------------------------------------------------------------
+// Subcommands
+// ---------------------------------------------------------------------------
+async function runbookList() {
+    const runbooks = findRunbooks();
+    if (runbooks.length === 0) {
+        console.log('No runbooks found.');
+        console.log('');
+        console.log('Create one at:');
+        for (const dir of RUNBOOK_DIRS.slice(0, 2)) {
+            console.log(`  ${dir}/<name>.yaml`);
+        }
+        return;
+    }
+    console.log('Available runbooks:\n');
+    for (const rb of runbooks) {
+        try {
+            const content = readFileSync(rb.path, 'utf-8');
+            const def = parseRunbookYaml(content);
+            console.log(`  ${def.name.padEnd(24)} ${def.description ?? ''}`);
+            console.log(`  ${''.padEnd(24)} (${rb.path})`);
+        }
+        catch {
+            console.log(`  ${basename(rb.path)} (parse error)`);
+        }
+    }
+}
+async function runbookRun(name, options) {
+    const runbooks = findRunbooks();
+    const match = runbooks.find(rb => {
+        try {
+            const def = parseRunbookYaml(readFileSync(rb.path, 'utf-8'));
+            return def.name === name || basename(rb.file, '.yaml') === name || basename(rb.file, '.yml') === name;
+        }
+        catch {
+            return false;
+        }
+    });
+    if (!match) {
+        console.error(`Runbook not found: ${name}`);
+        console.log('Run "nimbus runbook list" to see available runbooks.');
+        process.exit(1);
+    }
+    const def = parseRunbookYaml(readFileSync(match.path, 'utf-8'));
+    const prompt = buildRunbookPrompt(def);
+    console.log(`Executing runbook: ${def.name}`);
+    if (def.description)
+        console.log(`Description: ${def.description}`);
+    console.log(`Steps: ${def.steps.length}`);
+    console.log('');
+    if (!options.auto) {
+        // Prompt for confirmation in interactive mode
+        const readline = await import('node:readline');
+        const rl = readline.createInterface({ input: process.stdin, output: process.stdout });
+        const answer = await new Promise(resolve => {
+            rl.question('Proceed with runbook execution? (y/N) ', resolve);
+        });
+        rl.close();
+        if (!answer.toLowerCase().startsWith('y')) {
+            console.log('Runbook execution cancelled.');
+            return;
+        }
+    }
+    const { chatCommand } = await import('./chat');
+    await chatCommand({ initialPrompt: prompt, mode: 'deploy' });
+}
+async function runbookCreate(name) {
+    const targetDir = join(homedir(), '.nimbus', 'runbooks');
+    mkdirSync(targetDir, { recursive: true });
+    const targetPath = join(targetDir, `${name}.yaml`);
+    if (existsSync(targetPath)) {
+        console.error(`Runbook already exists: ${targetPath}`);
+        process.exit(1);
+    }
+    const readline = await import('node:readline');
+    const rl = readline.createInterface({ input: process.stdin, output: process.stdout });
+    const question = (q) => new Promise(resolve => rl.question(q, resolve));
+    console.log(`Creating runbook: ${name}`);
+    const description = await question('Description: ');
+    const context = await question('Context/profile (optional, e.g. "prod"): ');
+    console.log('Enter steps (empty line to finish):');
+    const steps = [];
+    let stepNum = 1;
+    while (true) {
+        const step = await question(`Step ${stepNum}: `);
+        if (!step.trim())
+            break;
+        steps.push(step.trim());
+        stepNum++;
+    }
+    rl.close();
+    if (steps.length === 0) {
+        console.error('Runbook must have at least one step.');
+        process.exit(1);
+    }
+    const yaml = [
+        `name: ${name}`,
+        `description: ${description}`,
+        context ? `context: ${context}` : '# context: prod',
+        'steps:',
+        ...steps.map(s => `  - ${s}`),
+    ].join('\n') + '\n';
+    writeFileSync(targetPath, yaml, 'utf-8');
+    console.log(`\nRunbook saved to: ${targetPath}`);
+    console.log(`Run with: nimbus runbook run ${name}`);
+}
+// ---------------------------------------------------------------------------
+// Main export
+// ---------------------------------------------------------------------------
+export async function runbookCommand(subcommand, args) {
+    switch (subcommand) {
+        case 'list':
+        case 'ls':
+            await runbookList();
+            break;
+        case 'run': {
+            const name = args[0];
+            if (!name) {
+                console.error('Usage: nimbus runbook run <name> [--auto]');
+                process.exit(1);
+            }
+            await runbookRun(name, { auto: args.includes('--auto') });
+            break;
+        }
+        case 'create':
+        case 'new': {
+            const name = args[0];
+            if (!name) {
+                console.error('Usage: nimbus runbook create <name>');
+                process.exit(1);
+            }
+            await runbookCreate(name);
+            break;
+        }
+        default:
+            console.log('Usage: nimbus runbook <list|run|create>');
+            console.log('');
+            console.log('  list               List available runbooks');
+            console.log('  run <name>         Execute a runbook as an agent prompt');
+            console.log('  create <name>      Create a new runbook interactively');
+            break;
+    }
+}