@dotsetlabs/bellwether 0.10.0

package/dist/cli/output.js

@@ -0,0 +1,438 @@
+/**
+ * CLI Output Module
+ *
+ * Provides structured output for CLI commands with support for:
+ * - Different message types (info, success, error, warning)
+ * - Quiet mode to suppress non-essential output
+ * - Consistent formatting across all commands
+ *
+ * This module is for USER-FACING output only. For diagnostic/debug logging,
+ * use the logging module (src/logging/logger.ts).
+ */
+/**
+ * Global output configuration.
+ */
+let globalConfig = {
+    quiet: false,
+    noColor: false,
+};
+/**
+ * Configure global output settings.
+ */
+export function configureOutput(config) {
+    globalConfig = { ...globalConfig, ...config };
+}
+/**
+ * Get current output configuration.
+ */
+export function getOutputConfig() {
+    return { ...globalConfig };
+}
+/**
+ * Reset output configuration to defaults.
+ */
+export function resetOutput() {
+    globalConfig = { quiet: false, noColor: false };
+}
+/**
+ * Check if output is in quiet mode.
+ */
+export function isQuiet() {
+    return globalConfig.quiet ?? false;
+}
+/**
+ * Standard information output.
+ * Use for progress messages, status updates, and general information.
+ */
+export function info(message) {
+    if (!globalConfig.quiet) {
+        console.log(message);
+    }
+}
+/**
+ * Success message output.
+ * Use for completion messages and positive confirmations.
+ */
+export function success(message) {
+    if (!globalConfig.quiet) {
+        console.log(message);
+    }
+}
+/**
+ * Warning message output.
+ * Always shown (not suppressed by quiet mode) as warnings are important.
+ */
+export function warn(message) {
+    console.warn(message);
+}
+/**
+ * Error message output.
+ * Always shown (not suppressed by quiet mode) as errors are critical.
+ */
+export function error(message) {
+    console.error(message);
+}
+/**
+ * Debug output (only shown in verbose mode).
+ * For detailed information during development/troubleshooting.
+ */
+export function debug(message, verbose = false) {
+    if (verbose && !globalConfig.quiet) {
+        console.log(message);
+    }
+}
+/**
+ * Print a blank line for formatting.
+ */
+export function newline() {
+    if (!globalConfig.quiet) {
+        console.log('');
+    }
+}
+/**
+ * Print multiple lines.
+ */
+export function lines(...messages) {
+    if (!globalConfig.quiet) {
+        for (const msg of messages) {
+            console.log(msg);
+        }
+    }
+}
+/**
+ * Print formatted JSON output.
+ * Always shown as this is typically requested data output.
+ */
+export function json(data) {
+    console.log(JSON.stringify(data, null, 2));
+}
+/**
+ * Print a section header.
+ */
+export function section(title) {
+    if (!globalConfig.quiet) {
+        console.log(`\n--- ${title} ---`);
+    }
+}
+/**
+ * Print a key-value pair.
+ */
+export function keyValue(key, value) {
+    if (!globalConfig.quiet && value !== undefined) {
+        console.log(`${key}: ${value}`);
+    }
+}
+/**
+ * Print a list item.
+ */
+export function listItem(item, indent = 0) {
+    if (!globalConfig.quiet) {
+        const prefix = '  '.repeat(indent) + '- ';
+        console.log(`${prefix}${item}`);
+    }
+}
+/**
+ * Print numbered list items.
+ */
+export function numberedList(items, startIndex = 1) {
+    if (!globalConfig.quiet) {
+        items.forEach((item, i) => {
+            console.log(`  ${startIndex + i}) ${item}`);
+        });
+    }
+}
+/**
+ * Create a scoped output instance for a specific command.
+ * Useful for commands that need to track their own quiet state.
+ */
+export function createOutput(config = {}) {
+    return new Output({ ...globalConfig, ...config });
+}
+/**
+ * Output class for scoped output with its own configuration.
+ */
+export class Output {
+    config;
+    constructor(config = {}) {
+        this.config = config;
+    }
+    info(message) {
+        if (!this.config.quiet) {
+            console.log(message);
+        }
+    }
+    success(message) {
+        if (!this.config.quiet) {
+            console.log(message);
+        }
+    }
+    warn(message) {
+        console.warn(message);
+    }
+    error(message) {
+        console.error(message);
+    }
+    debug(message, verbose = false) {
+        if (verbose && !this.config.quiet) {
+            console.log(message);
+        }
+    }
+    newline() {
+        if (!this.config.quiet) {
+            console.log('');
+        }
+    }
+    lines(...messages) {
+        if (!this.config.quiet) {
+            for (const msg of messages) {
+                console.log(msg);
+            }
+        }
+    }
+    json(data) {
+        console.log(JSON.stringify(data, null, 2));
+    }
+    section(title) {
+        if (!this.config.quiet) {
+            console.log(`\n--- ${title} ---`);
+        }
+    }
+    keyValue(key, value) {
+        if (!this.config.quiet && value !== undefined) {
+            console.log(`${key}: ${value}`);
+        }
+    }
+    listItem(item, indent = 0) {
+        if (!this.config.quiet) {
+            const prefix = '  '.repeat(indent) + '- ';
+            console.log(`${prefix}${item}`);
+        }
+    }
+    numberedList(items, startIndex = 1) {
+        if (!this.config.quiet) {
+            items.forEach((item, i) => {
+                console.log(`  ${startIndex + i}) ${item}`);
+            });
+        }
+    }
+}
+/**
+ * Streaming display controller for real-time LLM output.
+ * Provides clean, formatted output during streaming operations.
+ */
+export class StreamingDisplay {
+    config;
+    stream;
+    buffer = '';
+    lineLength = 0;
+    isActive = false;
+    quietMode;
+    constructor(config = {}) {
+        this.config = config;
+        this.stream = config.stream ?? process.stdout;
+        this.quietMode = globalConfig.quiet ?? false;
+    }
+    /**
+     * Start streaming display with optional prefix.
+     */
+    start(prefix) {
+        if (this.quietMode)
+            return;
+        this.isActive = true;
+        this.buffer = '';
+        this.lineLength = 0;
+        const displayPrefix = prefix ?? this.config.prefix;
+        if (displayPrefix) {
+            this.stream.write(displayPrefix);
+            this.lineLength = displayPrefix.length;
+        }
+    }
+    /**
+     * Write a chunk of streaming text.
+     */
+    write(chunk) {
+        if (this.quietMode || !this.isActive)
+            return;
+        this.buffer += chunk;
+        // Apply styling if configured
+        let styledChunk = chunk;
+        if (this.config.style === 'dim') {
+            styledChunk = `\x1b[2m${chunk}\x1b[0m`;
+        }
+        else if (this.config.style === 'bright') {
+            styledChunk = `\x1b[1m${chunk}\x1b[0m`;
+        }
+        // Handle line wrapping if maxWidth is set
+        if (this.config.maxWidth) {
+            const maxWidth = this.config.maxWidth;
+            for (const char of chunk) {
+                if (char === '\n') {
+                    this.stream.write('\n');
+                    this.lineLength = 0;
+                }
+                else {
+                    if (this.lineLength >= maxWidth) {
+                        this.stream.write('\n');
+                        this.lineLength = 0;
+                    }
+                    this.stream.write(this.config.style === 'dim' ? `\x1b[2m${char}\x1b[0m` : char);
+                    this.lineLength++;
+                }
+            }
+        }
+        else {
+            this.stream.write(styledChunk);
+            // Track line length for potential future use
+            const lastNewline = chunk.lastIndexOf('\n');
+            if (lastNewline >= 0) {
+                this.lineLength = chunk.length - lastNewline - 1;
+            }
+            else {
+                this.lineLength += chunk.length;
+            }
+        }
+    }
+    /**
+     * Complete the streaming display.
+     */
+    finish(suffix) {
+        if (this.quietMode)
+            return this.buffer;
+        this.isActive = false;
+        const displaySuffix = suffix ?? this.config.suffix;
+        if (displaySuffix) {
+            this.stream.write(displaySuffix);
+        }
+        // Ensure we end on a newline
+        if (this.lineLength > 0) {
+            this.stream.write('\n');
+        }
+        return this.buffer;
+    }
+    /**
+     * Abort the streaming display (e.g., on error).
+     */
+    abort(message) {
+        if (this.quietMode)
+            return;
+        this.isActive = false;
+        if (message) {
+            this.stream.write(`\n${message}\n`);
+        }
+        else if (this.lineLength > 0) {
+            this.stream.write('\n');
+        }
+    }
+    /**
+     * Get the complete buffer content.
+     */
+    getBuffer() {
+        return this.buffer;
+    }
+    /**
+     * Check if streaming is currently active.
+     */
+    isStreaming() {
+        return this.isActive;
+    }
+}
+/**
+ * Create a streaming display for interview operations.
+ * Provides context-appropriate prefixes and styling.
+ */
+export function createStreamingDisplay(operation, context) {
+    const prefixes = {
+        generating: context ? `Generating questions for ${context}... ` : 'Generating... ',
+        analyzing: context ? `Analyzing ${context}... ` : 'Analyzing... ',
+        synthesizing: context ? `Synthesizing ${context}... ` : 'Synthesizing... ',
+    };
+    return new StreamingDisplay({
+        prefix: prefixes[operation] ?? '',
+        style: 'dim',
+        maxWidth: 80,
+    });
+}
+/**
+ * Simple streaming callback that writes to stdout.
+ * Use this for basic streaming output without the full StreamingDisplay.
+ */
+export function createStreamingCallback(prefix) {
+    let started = false;
+    const quiet = globalConfig.quiet ?? false;
+    return {
+        onStart: (_operation, _context) => {
+            if (quiet)
+                return;
+            if (prefix) {
+                process.stdout.write(prefix);
+                started = true;
+            }
+        },
+        onChunk: (chunk, _operation) => {
+            if (quiet)
+                return;
+            if (!started && prefix) {
+                process.stdout.write(prefix);
+                started = true;
+            }
+            process.stdout.write(chunk);
+        },
+        onComplete: (_text, _operation) => {
+            if (quiet)
+                return;
+            if (started) {
+                process.stdout.write('\n');
+            }
+        },
+        onError: (error, _operation) => {
+            if (quiet)
+                return;
+            if (started) {
+                process.stdout.write(`\n[Error: ${error.message}]\n`);
+            }
+        },
+    };
+}
+/**
+ * Icon mapping for diff severity levels.
+ */
+const SEVERITY_ICONS = {
+    none: '✓',
+    info: 'ℹ',
+    warning: '⚠',
+    breaking: '✗',
+};
+/**
+ * Get the icon for a severity level.
+ */
+export function getSeverityIcon(severity) {
+    return SEVERITY_ICONS[severity] ?? '?';
+}
+/**
+ * Default export for convenient importing.
+ */
+export default {
+    configureOutput,
+    getOutputConfig,
+    resetOutput,
+    isQuiet,
+    info,
+    success,
+    warn,
+    error,
+    debug,
+    newline,
+    lines,
+    json,
+    section,
+    keyValue,
+    listItem,
+    numberedList,
+    createOutput,
+    Output,
+    StreamingDisplay,
+    createStreamingDisplay,
+    createStreamingCallback,
+    getSeverityIcon,
+};
+//# sourceMappingURL=output.js.map

package/dist/cli/utils/env.d.ts

@@ -0,0 +1,5 @@
+/**
+ * Detect if running in a CI environment.
+ */
+export declare function isCI(): boolean;
+//# sourceMappingURL=env.d.ts.map

package/dist/cli/utils/env.js

@@ -0,0 +1,14 @@
+/**
+ * Detect if running in a CI environment.
+ */
+export function isCI() {
+    return !!(process.env.CI ||
+        process.env.CONTINUOUS_INTEGRATION ||
+        process.env.GITHUB_ACTIONS ||
+        process.env.GITLAB_CI ||
+        process.env.CIRCLECI ||
+        process.env.JENKINS_URL ||
+        process.env.TRAVIS ||
+        process.env.BUILDKITE);
+}
+//# sourceMappingURL=env.js.map

package/dist/cli/utils/progress.d.ts

@@ -0,0 +1,59 @@
+/**
+ * Progress bar utilities for CLI test display.
+ */
+import type { InterviewProgress } from '../../interview/interviewer.js';
+export interface ProgressBarOptions {
+    /** Whether to show the progress bar (false for verbose mode) */
+    enabled?: boolean;
+    /** Stream to write to (defaults to stdout) */
+    stream?: NodeJS.WriteStream;
+}
+/**
+ * Creates and manages a progress bar for test progress.
+ */
+export declare class InterviewProgressBar {
+    private bar;
+    private enabled;
+    private started;
+    private totalWork;
+    private toolWork;
+    private currentValue;
+    private currentPayload;
+    constructor(options?: ProgressBarOptions);
+    /**
+     * Start the progress bar with initial values.
+     */
+    start(totalTools: number, totalPersonas: number, totalPrompts?: number, totalResources?: number): void;
+    /**
+     * Update the progress bar with current progress.
+     */
+    update(progress: InterviewProgress): void;
+    /**
+     * Stop and clear the progress bar.
+     */
+    stop(): void;
+    /**
+     * Log a message while the progress bar is active.
+     * Uses the same stream as the progress bar to avoid terminal overlap issues.
+     */
+    log(message: string): void;
+}
+/**
+ * Format a startup banner for the check command.
+ */
+export declare function formatCheckBanner(options: {
+    serverCommand: string;
+    toolCount?: number;
+}): string;
+/**
+ * Format a startup banner for the explore command.
+ */
+export declare function formatExploreBanner(options: {
+    serverCommand: string;
+    provider: string;
+    model: string;
+    personas: string[];
+    questionsPerTool: number;
+    toolCount?: number;
+}): string;
+//# sourceMappingURL=progress.d.ts.map