@dotsetlabs/bellwether 0.10.0

package/dist/cli/commands/baseline-migrate.js

@@ -0,0 +1,164 @@
+/**
+ * Baseline migrate command - upgrade baselines to current format version.
+ *
+ * This command migrates baseline files from older format versions to the
+ * current format version, ensuring compatibility with the latest CLI features.
+ */
+import { Command } from 'commander';
+import { existsSync, readFileSync, writeFileSync } from 'fs';
+import { join } from 'path';
+import { EXIT_CODES } from '../../constants.js';
+import * as output from '../output.js';
+import { formatVersion } from '../../baseline/version.js';
+import { migrateBaseline, getMigrationInfo, } from '../../baseline/migrations.js';
+import { recalculateIntegrityHash } from '../../baseline/saver.js';
+import { loadConfig, ConfigNotFoundError } from '../../config/loader.js';
+function loadConfigOrExit(configPath) {
+    try {
+        return loadConfig(configPath);
+    }
+    catch (error) {
+        if (error instanceof ConfigNotFoundError) {
+            output.error(error.message);
+            process.exit(EXIT_CODES.ERROR);
+        }
+        throw error;
+    }
+}
+/**
+ * Load raw baseline JSON without full validation.
+ * Used for migration where the format might not match current schema.
+ */
+function loadRawBaseline(path) {
+    if (!existsSync(path)) {
+        throw new Error(`Baseline file not found: ${path}`);
+    }
+    const content = readFileSync(path, 'utf-8');
+    try {
+        return JSON.parse(content);
+    }
+    catch (error) {
+        throw new Error(`Invalid JSON in baseline file ${path}: ${error instanceof Error ? error.message : 'Unknown error'}`);
+    }
+}
+/**
+ * Save migrated baseline to file.
+ */
+function saveMigratedBaseline(baseline, path) {
+    const serialized = JSON.stringify(baseline, null, 2);
+    writeFileSync(path, serialized, 'utf-8');
+}
+/**
+ * Create the migrate command.
+ */
+export const migrateCommand = new Command('migrate')
+    .description('Migrate baseline to current format version')
+    .argument('[path]', 'Path to baseline file')
+    .option('-c, --config <path>', 'Path to config file')
+    .option('--dry-run', 'Show what would change without writing')
+    .option('-o, --output <path>', 'Output path (default: overwrite input)')
+    .option('-f, --force', 'Overwrite output file without prompting')
+    .option('--info', 'Show migration info without performing migration')
+    .action(async (baselinePath, options) => {
+    try {
+        const config = loadConfigOrExit(options.config);
+        const outputDir = config.output.dir;
+        const resolvedBaselinePath = baselinePath ?? config.baseline.path;
+        if (!resolvedBaselinePath) {
+            output.error('No baseline path provided. Set baseline.path in config or pass a path argument.');
+            process.exit(EXIT_CODES.ERROR);
+        }
+        // Resolve path
+        const baseDir = baselinePath ? process.cwd() : outputDir;
+        const fullPath = resolvedBaselinePath.startsWith('/')
+            ? resolvedBaselinePath
+            : join(baseDir, resolvedBaselinePath);
+        // Load raw baseline
+        const rawBaseline = loadRawBaseline(fullPath);
+        // Get migration info
+        const info = getMigrationInfo(rawBaseline);
+        // Info mode - just show status
+        if (options.info) {
+            output.info('=== Baseline Migration Info ===');
+            output.info(`File: ${fullPath}`);
+            output.info(`Current format version: ${formatVersion(info.currentVersion)}`);
+            output.info(`Target format version: ${formatVersion(info.targetVersion)}`);
+            output.info(`Needs migration: ${info.needsMigration ? 'Yes' : 'No'}`);
+            if (info.needsMigration) {
+                output.info(`Migrations to apply: ${info.migrationsToApply.join(' -> ')}`);
+                output.info(`Can migrate: ${info.canMigrate ? 'Yes' : 'No'}`);
+            }
+            else {
+                output.success('Baseline is already at the current format version.');
+            }
+            return;
+        }
+        // Check if migration is needed
+        if (!info.needsMigration) {
+            output.success(`Baseline is already at the current format version (${formatVersion(info.currentVersion)}).`);
+            return;
+        }
+        // Check if migration is possible
+        if (!info.canMigrate) {
+            output.error(`Cannot migrate baseline from ${formatVersion(info.currentVersion)} ` +
+                `to ${formatVersion(info.targetVersion)}. ` +
+                `This may require a newer version of the CLI.`);
+            process.exit(EXIT_CODES.ERROR);
+        }
+        // Dry run mode
+        if (options.dryRun) {
+            output.info('=== Dry Run - No changes will be made ===');
+            output.info(`File: ${fullPath}`);
+            output.info(`Would migrate from ${formatVersion(info.currentVersion)} to ${formatVersion(info.targetVersion)}`);
+            output.info(`Migrations to apply: ${info.migrationsToApply.join(' -> ')}`);
+            // Show what would change
+            const migrated = migrateBaseline(rawBaseline);
+            output.info('\nMigrated baseline preview:');
+            output.info(`  Version: ${migrated.version}`);
+            output.info(`  Tools: ${migrated.tools.length}`);
+            output.info(`  Assertions: ${migrated.assertions.length}`);
+            if (migrated.workflowSignatures && migrated.workflowSignatures.length > 0) {
+                output.info(`  Workflows: ${migrated.workflowSignatures.length}`);
+            }
+            return;
+        }
+        // Determine output path
+        const outputPath = options.output
+            ? options.output.startsWith('/')
+                ? options.output
+                : join(process.cwd(), options.output)
+            : fullPath;
+        // Check if output file exists (when different from input)
+        if (outputPath !== fullPath && existsSync(outputPath) && !options.force) {
+            output.error(`Output file already exists: ${outputPath}`);
+            output.error('Use --force to overwrite or specify a different --output path.');
+            process.exit(EXIT_CODES.ERROR);
+        }
+        // Perform migration
+        output.info(`Migrating baseline from ${formatVersion(info.currentVersion)} to ${formatVersion(info.targetVersion)}...`);
+        const migrated = migrateBaseline(rawBaseline);
+        // Recalculate integrity hash after migration
+        // eslint-disable-next-line @typescript-eslint/no-unused-vars
+        const { integrityHash: _, ...baselineWithoutHash } = migrated;
+        const finalBaseline = recalculateIntegrityHash(baselineWithoutHash);
+        // Save migrated baseline
+        saveMigratedBaseline(finalBaseline, outputPath);
+        output.success(`Baseline migrated successfully!`);
+        output.info(`  From: ${formatVersion(info.currentVersion)}`);
+        output.info(`  To: ${formatVersion(info.targetVersion)}`);
+        output.info(`  Output: ${outputPath}`);
+        // Show summary
+        output.info('\nBaseline summary:');
+        output.info(`  Server: ${finalBaseline.server.name} v${finalBaseline.server.version}`);
+        output.info(`  Tools: ${finalBaseline.tools.length}`);
+        output.info(`  Assertions: ${finalBaseline.assertions.length}`);
+        if (finalBaseline.workflowSignatures && finalBaseline.workflowSignatures.length > 0) {
+            output.info(`  Workflows: ${finalBaseline.workflowSignatures.length}`);
+        }
+    }
+    catch (error) {
+        output.error(error instanceof Error ? error.message : String(error));
+        process.exit(EXIT_CODES.ERROR);
+    }
+});
+//# sourceMappingURL=baseline-migrate.js.map

package/dist/cli/commands/baseline.d.ts

@@ -0,0 +1,14 @@
+/**
+ * Baseline commands - manage baselines for drift detection.
+ *
+ * Subcommands:
+ *   - save [path]          Save test results as baseline
+ *   - compare <path>       Compare test results against baseline
+ *   - show [path]          Display baseline contents
+ *   - diff <path1> <path2> Compare two baseline files
+ *   - accept               Accept detected drift as intentional
+ *   - migrate              Upgrade baseline to current format
+ */
+import { Command } from 'commander';
+export declare const baselineCommand: Command;
+//# sourceMappingURL=baseline.d.ts.map

package/dist/cli/commands/baseline.js

@@ -0,0 +1,449 @@
+/**
+ * Baseline commands - manage baselines for drift detection.
+ *
+ * Subcommands:
+ *   - save [path]          Save test results as baseline
+ *   - compare <path>       Compare test results against baseline
+ *   - show [path]          Display baseline contents
+ *   - diff <path1> <path2> Compare two baseline files
+ *   - accept               Accept detected drift as intentional
+ *   - migrate              Upgrade baseline to current format
+ */
+import { Command } from 'commander';
+import { existsSync, readFileSync, writeFileSync } from 'fs';
+import { join, basename } from 'path';
+import { createBaseline, saveBaseline, loadBaseline, compareBaselines, formatDiffText, formatDiffJson, formatDiffMarkdown, formatDiffCompact, verifyIntegrity, } from '../../baseline/index.js';
+import { createCloudBaseline } from '../../baseline/converter.js';
+import { BaselineVersionError } from '../../baseline/version.js';
+import { EXIT_CODES } from '../../constants.js';
+import { migrateCommand } from './baseline-migrate.js';
+import { acceptCommand } from './baseline-accept.js';
+import { loadConfig, ConfigNotFoundError } from '../../config/loader.js';
+import * as output from '../output.js';
+/**
+ * Load interview result from JSON report.
+ * Only accepts check mode results - explore results are for documentation only.
+ */
+function loadInterviewResult(reportPath) {
+    if (!existsSync(reportPath)) {
+        throw new Error(`Test report not found: ${reportPath}\n\n` +
+            'Run `bellwether check` first with JSON output enabled.\n' +
+            'Configure in bellwether.yaml:\n' +
+            '  output:\n' +
+            '    format: json  # or "both" for JSON + markdown');
+    }
+    const content = readFileSync(reportPath, 'utf-8');
+    let result;
+    try {
+        result = JSON.parse(content);
+    }
+    catch (error) {
+        throw new Error(`Invalid JSON in report file ${reportPath}: ${error instanceof Error ? error.message : 'Unknown error'}`);
+    }
+    // Validate that this is a check mode result, not explore
+    if (result.metadata.model && result.metadata.model !== 'check') {
+        throw new Error(`Baseline operations only work with check mode results.\n\n` +
+            `The report at ${reportPath} was created with explore mode (model: ${result.metadata.model}).\n` +
+            `Explore results are for documentation only and cannot be used for baselines.\n\n` +
+            'To create a baseline:\n' +
+            '  1. Run `bellwether check` to generate a check mode report\n' +
+            '  2. Run `bellwether baseline save` to create the baseline');
+    }
+    return result;
+}
+/**
+ * Get the output directory from config or use current directory.
+ */
+function loadConfigOrExit(configPath) {
+    try {
+        return loadConfig(configPath);
+    }
+    catch (error) {
+        if (error instanceof ConfigNotFoundError) {
+            output.error(error.message);
+            process.exit(EXIT_CODES.ERROR);
+        }
+        throw error;
+    }
+}
+export const baselineCommand = new Command('baseline')
+    .description('Manage baselines for drift detection')
+    .addHelpText('after', `
+Examples:
+  $ bellwether baseline save                    # Save baseline from last test
+  $ bellwether baseline save ./my-baseline.json # Save to specific path
+  $ bellwether baseline compare ./baseline.json # Compare test against baseline
+  $ bellwether baseline show                    # Show current baseline
+  $ bellwether baseline diff v1.json v2.json    # Compare two baselines
+  $ bellwether baseline accept                  # Accept drift as intentional
+  $ bellwether baseline accept --reason "Added new feature"
+  $ bellwether baseline migrate                 # Upgrade baseline to current format
+  $ bellwether baseline migrate --info          # Check if migration is needed
+`);
+baselineCommand.addCommand(migrateCommand);
+baselineCommand.addCommand(acceptCommand);
+// baseline save
+baselineCommand
+    .command('save')
+    .description('Save test results as a baseline for drift detection')
+    .argument('[path]', 'Output path for baseline file')
+    .option('-c, --config <path>', 'Path to config file')
+    .option('--report <path>', 'Path to test report JSON file')
+    .option('--cloud', 'Save in cloud-compatible format')
+    .option('-f, --force', 'Overwrite existing baseline without prompting')
+    .action(async (baselinePath, options) => {
+    const config = loadConfigOrExit(options.config);
+    const outputDir = config.output.dir;
+    const defaultBaselinePath = config.baseline.savePath ?? config.baseline.path;
+    const resolvedBaselinePath = baselinePath ?? defaultBaselinePath;
+    if (!resolvedBaselinePath) {
+        output.error('No baseline path provided. Set baseline.path or baseline.savePath in config, or pass a path argument.');
+        process.exit(EXIT_CODES.ERROR);
+    }
+    // Find the report file
+    const reportPath = options.report || join(outputDir, config.output.files.checkReport);
+    // Load interview result
+    let result;
+    try {
+        result = loadInterviewResult(reportPath);
+    }
+    catch (error) {
+        output.error(error instanceof Error ? error.message : String(error));
+        process.exit(EXIT_CODES.ERROR);
+    }
+    // Determine baseline path (relative to output dir if not absolute)
+    const finalPath = resolvedBaselinePath.startsWith('/')
+        ? resolvedBaselinePath
+        : join(outputDir, resolvedBaselinePath);
+    // Check for existing baseline
+    if (existsSync(finalPath) && !options.force) {
+        output.error(`Baseline already exists: ${finalPath}`);
+        output.error('Use --force to overwrite.');
+        process.exit(EXIT_CODES.ERROR);
+    }
+    // Extract server command from result metadata
+    const serverCommand = result.metadata.serverCommand || 'unknown';
+    // Create and save baseline
+    if (options.cloud) {
+        const cloudBaseline = createCloudBaseline(result, serverCommand);
+        writeFileSync(finalPath, JSON.stringify(cloudBaseline, null, 2));
+        output.success(`Cloud baseline saved: ${finalPath}`);
+    }
+    else {
+        const baseline = createBaseline(result, serverCommand);
+        saveBaseline(baseline, finalPath);
+        output.success(`Baseline saved: ${finalPath}`);
+    }
+    // Show summary
+    const assertionCount = result.toolProfiles.reduce((sum, p) => sum + p.behavioralNotes.length + p.limitations.length + p.securityNotes.length, 0);
+    output.info(`  Server: ${result.discovery.serverInfo.name} v${result.discovery.serverInfo.version}`);
+    output.info(`  Tools: ${result.toolProfiles.length}`);
+    output.info(`  Assertions: ${assertionCount}`);
+});
+// baseline compare
+baselineCommand
+    .command('compare')
+    .description('Compare test results against a baseline')
+    .argument('[baseline-path]', 'Path to baseline file to compare against')
+    .option('-c, --config <path>', 'Path to config file')
+    .option('--report <path>', 'Path to test report JSON file')
+    .option('--format <format>', 'Output format: text, json, markdown, compact')
+    .option('--fail-on-drift', 'Exit with error if drift is detected')
+    .option('--ignore-version-mismatch', 'Force comparison even if format versions are incompatible')
+    .action(async (baselinePath, options) => {
+    const config = loadConfigOrExit(options.config);
+    const outputDir = config.output.dir;
+    const format = options.format ?? config.baseline.outputFormat;
+    const failOnDrift = options.failOnDrift ? true : config.baseline.failOnDrift;
+    const resolvedBaselinePath = baselinePath ?? config.baseline.comparePath ?? config.baseline.path;
+    // Load baseline
+    if (!resolvedBaselinePath) {
+        output.error('No baseline path provided. Set baseline.path or baseline.comparePath in config, or pass a path argument.');
+        process.exit(EXIT_CODES.ERROR);
+    }
+    const baselineBaseDir = baselinePath ? process.cwd() : outputDir;
+    const fullBaselinePath = resolvedBaselinePath.startsWith('/')
+        ? resolvedBaselinePath
+        : join(baselineBaseDir, resolvedBaselinePath);
+    if (!existsSync(fullBaselinePath)) {
+        output.error(`Baseline not found: ${fullBaselinePath}`);
+        process.exit(EXIT_CODES.ERROR);
+    }
+    let previousBaseline;
+    try {
+        previousBaseline = loadBaseline(fullBaselinePath);
+    }
+    catch (error) {
+        output.error(`Failed to load baseline: ${error instanceof Error ? error.message : error}`);
+        process.exit(EXIT_CODES.ERROR);
+    }
+    // Find and load the report file
+    const reportPath = options.report || join(outputDir, config.output.files.checkReport);
+    let result;
+    try {
+        result = loadInterviewResult(reportPath);
+    }
+    catch (error) {
+        output.error(error instanceof Error ? error.message : String(error));
+        process.exit(EXIT_CODES.ERROR);
+    }
+    // Create current baseline for comparison
+    const serverCommand = result.metadata.serverCommand || 'unknown';
+    const currentBaseline = createBaseline(result, serverCommand);
+    // Compare baselines
+    let diff;
+    try {
+        diff = compareBaselines(previousBaseline, currentBaseline, {
+            ignoreVersionMismatch: options.ignoreVersionMismatch,
+        });
+    }
+    catch (error) {
+        if (error instanceof BaselineVersionError) {
+            output.error('Version Compatibility Error:');
+            output.error(error.message);
+            output.error(`\nBaseline version: ${error.sourceVersion}`);
+            output.error(`Current version: ${error.targetVersion}`);
+            output.error('\nTo fix this, either:');
+            output.error('  1. Run: bellwether baseline migrate <baseline-path>');
+            output.error('  2. Use: --ignore-version-mismatch (results may be incorrect)');
+            process.exit(EXIT_CODES.ERROR);
+        }
+        throw error;
+    }
+    // Show version compatibility warning if applicable
+    if (diff.versionCompatibility?.warning) {
+        output.warn(`Version Warning: ${diff.versionCompatibility.warning}`);
+        output.newline();
+    }
+    // Format and output
+    switch (format) {
+        case 'json':
+            console.log(formatDiffJson(diff));
+            break;
+        case 'markdown':
+            console.log(formatDiffMarkdown(diff));
+            break;
+        case 'compact':
+            console.log(formatDiffCompact(diff));
+            break;
+        default:
+            output.info('--- Drift Report ---');
+            output.info(formatDiffText(diff));
+    }
+    // Show summary
+    const totalChanges = diff.toolsAdded.length + diff.toolsRemoved.length + diff.toolsModified.length;
+    output.newline();
+    output.info(`Changes: ${totalChanges} tools affected`);
+    output.info(`Severity: ${diff.severity}`);
+    if (diff.versionCompatibility) {
+        output.info(`Format versions: ${diff.versionCompatibility.sourceVersion} -> ${diff.versionCompatibility.targetVersion}`);
+    }
+    // Exit with error if drift detected and --fail-on-drift
+    if (failOnDrift) {
+        if (diff.severity === 'breaking') {
+            output.error('\nBreaking changes detected!');
+            process.exit(EXIT_CODES.ERROR);
+        }
+        else if (diff.severity === 'warning') {
+            output.warn('\nWarning-level changes detected.');
+            process.exit(EXIT_CODES.ERROR);
+        }
+    }
+});
+// baseline show
+baselineCommand
+    .command('show')
+    .description('Display baseline contents')
+    .argument('[path]', 'Path to baseline file')
+    .option('-c, --config <path>', 'Path to config file')
+    .option('--json', 'Output raw JSON')
+    .option('--tools', 'Show only tool fingerprints')
+    .option('--assertions', 'Show only assertions')
+    .action(async (baselinePath, options) => {
+    const config = loadConfigOrExit(options.config);
+    const outputDir = config.output.dir;
+    const resolvedBaselinePath = baselinePath ?? config.baseline.comparePath ?? config.baseline.path;
+    if (!resolvedBaselinePath) {
+        output.error('No baseline path provided. Set baseline.path or baseline.comparePath in config, or pass a path argument.');
+        process.exit(EXIT_CODES.ERROR);
+    }
+    // Determine full path
+    const fullPath = resolvedBaselinePath.startsWith('/')
+        ? resolvedBaselinePath
+        : join(outputDir, resolvedBaselinePath);
+    if (!existsSync(fullPath)) {
+        output.error(`Baseline not found: ${fullPath}`);
+        output.error('\nRun `bellwether baseline save` to create a baseline.');
+        process.exit(EXIT_CODES.ERROR);
+    }
+    let baseline;
+    try {
+        baseline = loadBaseline(fullPath);
+    }
+    catch (error) {
+        output.error(`Failed to load baseline: ${error instanceof Error ? error.message : error}`);
+        process.exit(EXIT_CODES.ERROR);
+    }
+    // Raw JSON output
+    if (options.json) {
+        console.log(JSON.stringify(baseline, null, 2));
+        return;
+    }
+    // Formatted output
+    output.info('=== Baseline ===');
+    output.info(`File: ${fullPath}`);
+    output.info(`Format Version: ${baseline.version}`);
+    output.info(`Created: ${baseline.createdAt instanceof Date ? baseline.createdAt.toISOString() : baseline.createdAt}`);
+    output.info(`Mode: ${baseline.mode || 'check'}`);
+    output.info(`Server Command: ${baseline.serverCommand}`);
+    output.newline();
+    output.info('--- Server ---');
+    output.info(`Name: ${baseline.server.name}`);
+    output.info(`Version: ${baseline.server.version}`);
+    output.info(`Protocol: ${baseline.server.protocolVersion}`);
+    output.info(`Capabilities: ${baseline.server.capabilities.join(', ')}`);
+    output.newline();
+    // Tools
+    if (!options.assertions) {
+        output.info(`--- Tools (${baseline.tools.length}) ---`);
+        for (const tool of baseline.tools) {
+            output.info(`\n  ${tool.name}`);
+            output.info(`    Description: ${tool.description.slice(0, 80)}${tool.description.length > 80 ? '...' : ''}`);
+            output.info(`    Schema Hash: ${tool.schemaHash}`);
+            if (tool.securityNotes.length > 0) {
+                output.info(`    Security Notes: ${tool.securityNotes.length}`);
+            }
+            if (tool.limitations.length > 0) {
+                output.info(`    Limitations: ${tool.limitations.length}`);
+            }
+        }
+        output.newline();
+    }
+    // Assertions
+    if (!options.tools) {
+        output.info(`--- Assertions (${baseline.assertions.length}) ---`);
+        const byTool = new Map();
+        for (const assertion of baseline.assertions) {
+            const existing = byTool.get(assertion.tool) || [];
+            existing.push(assertion);
+            byTool.set(assertion.tool, existing);
+        }
+        for (const [tool, assertions] of byTool) {
+            output.info(`\n  ${tool}:`);
+            for (const a of assertions.slice(0, 5)) {
+                const icon = a.isPositive ? '+' : '-';
+                output.info(`    [${icon}] ${a.aspect}: ${a.assertion.slice(0, 60)}${a.assertion.length > 60 ? '...' : ''}`);
+            }
+            if (assertions.length > 5) {
+                output.info(`    ... and ${assertions.length - 5} more`);
+            }
+        }
+        output.newline();
+    }
+    // Workflows
+    if (baseline.workflowSignatures && baseline.workflowSignatures.length > 0) {
+        output.info(`--- Workflows (${baseline.workflowSignatures.length}) ---`);
+        for (const wf of baseline.workflowSignatures) {
+            const icon = wf.succeeded ? '\u2713' : '\u2717';
+            output.info(`  ${icon} ${wf.name}: ${wf.toolSequence.join(' -> ')}`);
+        }
+        output.newline();
+    }
+    // Summary
+    output.info('--- Summary ---');
+    output.info(baseline.summary.slice(0, 500) + (baseline.summary.length > 500 ? '...' : ''));
+    // Integrity check
+    output.newline();
+    const isValid = verifyIntegrity(baseline);
+    if (isValid) {
+        output.success('Integrity: Valid');
+    }
+    else {
+        output.warn('Integrity: INVALID - file may have been modified');
+    }
+});
+// baseline diff
+baselineCommand
+    .command('diff')
+    .description('Compare two baseline files')
+    .argument('<path1>', 'Path to first baseline file')
+    .argument('<path2>', 'Path to second baseline file')
+    .option('-c, --config <path>', 'Path to config file')
+    .option('--format <format>', 'Output format: text, json, markdown, compact')
+    .option('--ignore-version-mismatch', 'Force comparison even if format versions are incompatible')
+    .action(async (path1, path2, options) => {
+    const config = loadConfigOrExit(options.config);
+    const format = options.format ?? config.baseline.outputFormat;
+    // Load both baselines
+    if (!existsSync(path1)) {
+        output.error(`Baseline not found: ${path1}`);
+        process.exit(EXIT_CODES.ERROR);
+    }
+    if (!existsSync(path2)) {
+        output.error(`Baseline not found: ${path2}`);
+        process.exit(EXIT_CODES.ERROR);
+    }
+    let baseline1, baseline2;
+    try {
+        baseline1 = loadBaseline(path1);
+        baseline2 = loadBaseline(path2);
+    }
+    catch (error) {
+        output.error(`Failed to load baseline: ${error instanceof Error ? error.message : error}`);
+        process.exit(EXIT_CODES.ERROR);
+    }
+    // Compare
+    let diff;
+    try {
+        diff = compareBaselines(baseline1, baseline2, {
+            ignoreVersionMismatch: options.ignoreVersionMismatch,
+        });
+    }
+    catch (error) {
+        if (error instanceof BaselineVersionError) {
+            output.error('Version Compatibility Error:');
+            output.error(error.message);
+            output.error(`\nBaseline 1 version: ${error.sourceVersion}`);
+            output.error(`Baseline 2 version: ${error.targetVersion}`);
+            output.error('\nTo fix this, either:');
+            output.error('  1. Run: bellwether baseline migrate <baseline-path>');
+            output.error('  2. Use: --ignore-version-mismatch (results may be incorrect)');
+            process.exit(EXIT_CODES.ERROR);
+        }
+        throw error;
+    }
+    // Header
+    output.info(`Comparing baselines:`);
+    output.info(`  Old: ${basename(path1)} (${baseline1.createdAt instanceof Date ? baseline1.createdAt.toISOString().split('T')[0] : 'unknown'}) [${baseline1.version}]`);
+    output.info(`  New: ${basename(path2)} (${baseline2.createdAt instanceof Date ? baseline2.createdAt.toISOString().split('T')[0] : 'unknown'}) [${baseline2.version}]`);
+    output.newline();
+    // Show version compatibility warning if applicable
+    if (diff.versionCompatibility?.warning) {
+        output.warn(`Version Warning: ${diff.versionCompatibility.warning}`);
+        output.newline();
+    }
+    // Format and output
+    switch (format) {
+        case 'json':
+            console.log(formatDiffJson(diff));
+            break;
+        case 'markdown':
+            console.log(formatDiffMarkdown(diff));
+            break;
+        case 'compact':
+            console.log(formatDiffCompact(diff));
+            break;
+        default:
+            output.info(formatDiffText(diff));
+    }
+    // Summary
+    output.newline();
+    output.info(`Severity: ${diff.severity}`);
+    output.info(`Tools added: ${diff.toolsAdded.length}`);
+    output.info(`Tools removed: ${diff.toolsRemoved.length}`);
+    output.info(`Tools modified: ${diff.toolsModified.length}`);
+    if (diff.versionCompatibility) {
+        output.info(`Format versions: ${diff.versionCompatibility.sourceVersion} -> ${diff.versionCompatibility.targetVersion}`);
+    }
+});
+//# sourceMappingURL=baseline.js.map

package/dist/cli/commands/beta.d.ts

@@ -0,0 +1,10 @@
+/**
+ * Beta command for Bellwether Cloud beta access management.
+ *
+ * Subcommands:
+ * - status: Check beta status and user's access
+ * - invite <code>: Enter and verify an invitation code
+ */
+import { Command } from 'commander';
+export declare const betaCommand: Command;
+//# sourceMappingURL=beta.d.ts.map