@dotsetlabs/bellwether 0.10.0

package/dist/cli/utils/progress.js

@@ -0,0 +1,206 @@
+/**
+ * Progress bar utilities for CLI test display.
+ */
+import cliProgress from 'cli-progress';
+import { suppressLogs, restoreLogLevel } from '../../logging/logger.js';
+import { DISPLAY_LIMITS } from '../../constants.js';
+/**
+ * Creates and manages a progress bar for test progress.
+ */
+export class InterviewProgressBar {
+    bar = null;
+    enabled;
+    started = false;
+    totalWork = 0;
+    toolWork = 0;
+    currentValue = 0;
+    currentPayload = {};
+    constructor(options = {}) {
+        const stream = options.stream ?? process.stderr;
+        // Only enable progress bar if running in a TTY terminal
+        this.enabled = (options.enabled ?? true) && (stream.isTTY ?? false);
+        if (this.enabled) {
+            this.bar = new cliProgress.SingleBar({
+                format: '{bar} {percentage}% | {phase}: {item} ({current}/{phaseTotal}) | {questions} questions',
+                barCompleteChar: '\u2588',
+                barIncompleteChar: '\u2591',
+                hideCursor: true,
+                clearOnComplete: true,
+                stream,
+                // Force redraw on every update to prevent stale display
+                forceRedraw: true,
+                // Disable line wrapping to prevent display issues
+                linewrap: false,
+                // Synchronous updates prevent race conditions with terminal output
+                synchronousUpdate: true,
+            }, cliProgress.Presets.shades_classic);
+        }
+    }
+    /**
+     * Start the progress bar with initial values.
+     */
+    start(totalTools, totalPersonas, totalPrompts = 0, totalResources = 0) {
+        if (!this.enabled || !this.bar)
+            return;
+        // Suppress logging while progress bar is active to prevent interference
+        suppressLogs();
+        // Calculate total work across all phases
+        this.toolWork = totalTools * totalPersonas;
+        this.totalWork = this.toolWork + totalPrompts + totalResources;
+        this.bar.start(this.totalWork, 0, {
+            phase: 'Starting',
+            item: '...',
+            current: 0,
+            phaseTotal: totalTools,
+            questions: 0,
+        });
+        this.started = true;
+    }
+    /**
+     * Update the progress bar with current progress.
+     */
+    update(progress) {
+        if (!this.enabled || !this.bar || !this.started)
+            return;
+        // Handle workflow phase differently
+        if (progress.phase === 'workflows' && progress.totalWorkflows) {
+            this.bar.update(progress.workflowsCompleted ?? 0, {
+                phase: 'Workflows',
+                item: progress.currentWorkflow ?? '...',
+                current: (progress.workflowsCompleted ?? 0) + 1,
+                phaseTotal: progress.totalWorkflows,
+                questions: progress.questionsAsked,
+            });
+            return;
+        }
+        // Calculate completed work based on current phase
+        let completedWork;
+        let phaseLabel;
+        let currentItem;
+        let currentNum;
+        let totalNum;
+        if (progress.phase === 'interviewing') {
+            // Tools phase: count completed tools across personas
+            completedWork = progress.personasCompleted * progress.totalTools + progress.toolsCompleted;
+            phaseLabel = progress.currentPersona ?? 'Interviewing';
+            currentItem = progress.currentTool ?? '...';
+            currentNum = progress.toolsCompleted + 1;
+            totalNum = progress.totalTools;
+        }
+        else if (progress.phase === 'prompts') {
+            // Prompts phase: all tools done + prompts completed
+            completedWork = this.toolWork + (progress.promptsCompleted ?? 0);
+            phaseLabel = 'Prompts';
+            currentItem = progress.currentTool?.replace('prompt:', '') ?? '...';
+            currentNum = (progress.promptsCompleted ?? 0) + 1;
+            totalNum = progress.totalPrompts ?? 0;
+        }
+        else if (progress.phase === 'resources') {
+            // Resources phase: all tools done + all prompts done + resources completed
+            completedWork = this.toolWork + (progress.totalPrompts ?? 0) + (progress.resourcesCompleted ?? 0);
+            phaseLabel = 'Resources';
+            currentItem = progress.currentTool?.replace('resource:', '') ?? '...';
+            currentNum = (progress.resourcesCompleted ?? 0) + 1;
+            totalNum = progress.totalResources ?? 0;
+        }
+        else {
+            // Default/starting phase
+            completedWork = 0;
+            phaseLabel = 'Starting';
+            currentItem = '...';
+            currentNum = 0;
+            totalNum = progress.totalTools;
+        }
+        // Track current state for potential restart after logging
+        this.currentValue = completedWork;
+        this.currentPayload = {
+            phase: phaseLabel,
+            item: currentItem,
+            current: currentNum,
+            phaseTotal: totalNum,
+            questions: progress.questionsAsked,
+        };
+        this.bar.update(completedWork, this.currentPayload);
+    }
+    /**
+     * Stop and clear the progress bar.
+     */
+    stop() {
+        if (!this.enabled || !this.bar || !this.started)
+            return;
+        this.bar.stop();
+        this.started = false;
+        // Restore logging after progress bar is done
+        restoreLogLevel();
+    }
+    /**
+     * Log a message while the progress bar is active.
+     * Uses the same stream as the progress bar to avoid terminal overlap issues.
+     */
+    log(message) {
+        if (!this.enabled || !this.bar || !this.started) {
+            console.log(message);
+            return;
+        }
+        // Stop the progress bar temporarily to prevent overlap
+        this.bar.stop();
+        // Write to stderr (same stream as progress bar) to avoid mixing streams
+        process.stderr.write(message + '\n');
+        // Restart the progress bar with tracked state
+        this.bar.start(this.totalWork, this.currentValue, this.currentPayload);
+    }
+}
+/**
+ * Format a startup banner for the check command.
+ */
+export function formatCheckBanner(options) {
+    const { serverCommand, toolCount } = options;
+    // Truncate server command if too long
+    const maxCmdLen = DISPLAY_LIMITS.BANNER_COMMAND_MAX_LENGTH;
+    const displayCmd = serverCommand.length > maxCmdLen
+        ? serverCommand.substring(0, maxCmdLen - 3) + '...'
+        : serverCommand;
+    const lines = [
+        'Bellwether Check - Schema Validation & Drift Detection',
+        '',
+        '\u250C' + '\u2500'.repeat(50) + '\u2510',
+        `\u2502 Server:    ${displayCmd.padEnd(38)}\u2502`,
+        `\u2502 Mode:      ${'Check (free, deterministic)'.padEnd(38)}\u2502`,
+    ];
+    if (toolCount !== undefined) {
+        lines.push(`\u2502 Tools:     ${String(toolCount + ' discovered').padEnd(38)}\u2502`);
+    }
+    lines.push('\u2514' + '\u2500'.repeat(50) + '\u2518');
+    return lines.join('\n');
+}
+/**
+ * Format a startup banner for the explore command.
+ */
+export function formatExploreBanner(options) {
+    const { serverCommand, provider, model, personas, questionsPerTool, toolCount, } = options;
+    // Truncate server command if too long
+    const maxCmdLen = DISPLAY_LIMITS.BANNER_COMMAND_MAX_LENGTH;
+    const displayCmd = serverCommand.length > maxCmdLen
+        ? serverCommand.substring(0, maxCmdLen - 3) + '...'
+        : serverCommand;
+    const personaList = personas.join(', ');
+    const personaLabel = `${personaList} (${personas.length})`;
+    const lines = [
+        'Bellwether Explore - Behavioral Documentation',
+        '',
+        '\u250C' + '\u2500'.repeat(50) + '\u2510',
+        `\u2502 Server:    ${displayCmd.padEnd(38)}\u2502`,
+        `\u2502 Provider:  ${provider.padEnd(38)}\u2502`,
+        `\u2502 Model:     ${model.padEnd(38)}\u2502`,
+        `\u2502 Personas:  ${personaLabel.padEnd(38)}\u2502`,
+        `\u2502 Questions: ${String(questionsPerTool + ' per tool').padEnd(38)}\u2502`,
+    ];
+    if (toolCount !== undefined) {
+        lines.push(`\u2502 Tools:     ${String(toolCount + ' discovered').padEnd(38)}\u2502`);
+    }
+    lines.push('\u2514' + '\u2500'.repeat(50) + '\u2518');
+    lines.push('');
+    lines.push('Tip: For drift detection, use "bellwether check" instead');
+    return lines.join('\n');
+}
+//# sourceMappingURL=progress.js.map

package/dist/cli/utils/server-context.d.ts

@@ -0,0 +1,10 @@
+import type { ServerContext } from '../../interview/types.js';
+/**
+ * Extract server context from command and arguments.
+ *
+ * Analyzes the server command to provide hints about the server type
+ * (filesystem, database, git, etc.) and extracts path arguments for
+ * allowed directories.
+ */
+export declare function extractServerContextFromArgs(command: string, args: string[]): ServerContext;
+//# sourceMappingURL=server-context.d.ts.map

package/dist/cli/utils/server-context.js

@@ -0,0 +1,36 @@
+/**
+ * Extract server context from command and arguments.
+ *
+ * Analyzes the server command to provide hints about the server type
+ * (filesystem, database, git, etc.) and extracts path arguments for
+ * allowed directories.
+ */
+export function extractServerContextFromArgs(command, args) {
+    const context = {
+        allowedDirectories: [],
+        constraints: [],
+        hints: [],
+    };
+    const fullCommand = `${command} ${args.join(' ')}`.toLowerCase();
+    const pathArgs = args.filter((arg) => arg.startsWith('/') && !arg.startsWith('--'));
+    if (fullCommand.includes('filesystem') || fullCommand.includes('file-system')) {
+        context.allowedDirectories = pathArgs;
+        if (context.allowedDirectories.length > 0) {
+            context.hints.push(`Filesystem server with allowed directories: ${context.allowedDirectories.join(', ')}`);
+        }
+        context.constraints.push('Operations limited to specified directories');
+    }
+    else if (fullCommand.includes('postgres') || fullCommand.includes('mysql') || fullCommand.includes('sqlite')) {
+        context.hints.push('Database server - SQL operations expected');
+        context.constraints.push('Database operations only');
+    }
+    else if (fullCommand.includes('git')) {
+        context.allowedDirectories = pathArgs;
+        context.hints.push('Git server - repository operations expected');
+    }
+    else {
+        context.allowedDirectories = pathArgs;
+    }
+    return context;
+}
+//# sourceMappingURL=server-context.js.map

package/dist/cloud/auth.d.ts

@@ -0,0 +1,144 @@
+/**
+ * Authentication module for Bellwether Cloud.
+ *
+ * Handles session storage, retrieval, and management.
+ * Sessions are stored in ~/.bellwether/session.json with restricted permissions.
+ */
+import type { StoredSession, ProjectLink, SessionTeam } from './types.js';
+/**
+ * Directory for bellwether configuration.
+ */
+export declare const CONFIG_DIR: string;
+/**
+ * Path to session file.
+ */
+export declare const SESSION_FILE: string;
+/**
+ * Environment variable name for session token.
+ */
+export declare const SESSION_ENV_VAR = "BELLWETHER_SESSION";
+/**
+ * Environment variable name for API base URL.
+ */
+export declare const BASE_URL_ENV_VAR = "BELLWETHER_API_URL";
+/**
+ * Environment variable name for team ID override.
+ */
+export declare const TEAM_ID_ENV_VAR = "BELLWETHER_TEAM_ID";
+/**
+ * Session token prefix for validation.
+ */
+export declare const SESSION_PREFIX: "sess_";
+/**
+ * Mock session prefix for development.
+ */
+export declare const MOCK_SESSION_PREFIX: "sess_mock_";
+/**
+ * Ensure the config directory exists.
+ */
+export declare function ensureConfigDir(): void;
+/**
+ * Get the stored session.
+ * Returns null if no session exists, session is expired, or file is corrupted.
+ */
+export declare function getStoredSession(): StoredSession | null;
+/**
+ * Save session to disk.
+ * File is created with 0600 permissions (owner read/write only).
+ */
+export declare function saveSession(session: StoredSession): void;
+/**
+ * Clear the stored session.
+ */
+export declare function clearSession(): void;
+/**
+ * Get the session token.
+ *
+ * Priority:
+ * 1. BELLWETHER_SESSION environment variable
+ * 2. Stored session in ~/.bellwether/session.json
+ */
+export declare function getSessionToken(): string | undefined;
+/**
+ * Get the API base URL.
+ *
+ * Priority:
+ * 1. BELLWETHER_API_URL environment variable
+ * 2. Default: https://api.bellwether.sh
+ *
+ * Security: Validates that custom URLs use HTTPS (except localhost for development).
+ */
+export declare function getBaseUrl(): string;
+/**
+ * Check if a session token appears valid (strict format check).
+ * Validates against exact patterns to prevent injection.
+ */
+export declare function isValidSessionFormat(token: string): boolean;
+/**
+ * Check if a session token is a mock session (for development).
+ */
+export declare function isMockSession(token: string): boolean;
+/**
+ * Check if currently authenticated.
+ */
+export declare function isAuthenticated(): boolean;
+/**
+ * Get the active team ID.
+ *
+ * Priority:
+ * 1. BELLWETHER_TEAM_ID environment variable
+ * 2. Team ID from project link (if in a linked project directory)
+ * 3. Active team ID from stored session
+ */
+export declare function getTeamId(projectDir?: string): string | undefined;
+/**
+ * Get the active team details.
+ * Returns the full team object if available.
+ */
+export declare function getActiveTeam(projectDir?: string): SessionTeam | undefined;
+/**
+ * Get all teams from the stored session.
+ */
+export declare function getSessionTeams(): SessionTeam[];
+/**
+ * Set the active team in the stored session.
+ * Returns true if successful, false if team not found in session.
+ */
+export declare function setActiveTeam(teamId: string): boolean;
+/**
+ * Update the session token in the stored session.
+ * Called when the server rotates the token and returns a new one.
+ *
+ * @param newToken - The new session token from the server
+ * @returns Promise that resolves when the session is updated
+ */
+export declare function updateSessionToken(newToken: string): Promise<void>;
+/**
+ * Directory name for per-project bellwether config.
+ */
+export declare const PROJECT_CONFIG_DIR = ".bellwether";
+/**
+ * File name for project link configuration.
+ */
+export declare const LINK_FILE = "link.json";
+/**
+ * Get the project link file path for a given directory.
+ */
+export declare function getLinkFilePath(projectDir?: string): string;
+/**
+ * Get the linked project for the current directory.
+ */
+export declare function getLinkedProject(projectDir?: string): ProjectLink | null;
+/**
+ * Save a project link for the current directory.
+ */
+export declare function saveProjectLink(link: ProjectLink, projectDir?: string): void;
+/**
+ * Remove the project link for the current directory.
+ */
+export declare function removeProjectLink(projectDir?: string): boolean;
+/**
+ * Check if the current directory is linked to a project.
+ */
+export declare function isLinked(projectDir?: string): boolean;
+//# sourceMappingURL=auth.d.ts.map