@dotsetlabs/bellwether 0.10.0

package/dist/cli/commands/cloud/teams.js

@@ -0,0 +1,169 @@
+/**
+ * Teams command for managing team selection in Bellwether Cloud.
+ *
+ * Allows users to list their teams and switch the active team for API requests.
+ */
+import { Command } from 'commander';
+import { getStoredSession, getSessionTeams, setActiveTeam, getTeamId, TEAM_ID_ENV_VAR, } from '../../../cloud/auth.js';
+import { EXIT_CODES } from '../../../constants.js';
+import * as output from '../../output.js';
+export const teamsCommand = new Command('teams')
+    .description('Manage team selection for cloud operations')
+    .option('--json', 'Output as JSON')
+    .action(async (options) => {
+    // List teams by default
+    const session = getStoredSession();
+    if (!session) {
+        output.error('Not logged in.');
+        output.error('Run `bellwether login` first.');
+        process.exit(EXIT_CODES.ERROR);
+    }
+    const teams = getSessionTeams();
+    if (teams.length === 0) {
+        output.warn('No teams found in session.');
+        output.info('Try logging out and back in: `bellwether login --logout && bellwether login`');
+        return;
+    }
+    // Check for env var override
+    const envTeamId = process.env[TEAM_ID_ENV_VAR];
+    const effectiveTeamId = getTeamId();
+    if (options.json) {
+        output.info(JSON.stringify({
+            teams,
+            activeTeamId: session.activeTeamId,
+            effectiveTeamId,
+            envOverride: envTeamId || null,
+        }, null, 2));
+        return;
+    }
+    output.info('Your Teams');
+    output.info('-----------');
+    for (const team of teams) {
+        const isActive = team.id === session.activeTeamId;
+        const isEffective = team.id === effectiveTeamId;
+        const markers = [];
+        if (isActive)
+            markers.push('active');
+        if (envTeamId && isEffective)
+            markers.push('env override');
+        const suffix = markers.length > 0 ? ` (${markers.join(', ')})` : '';
+        const roleStr = `[${team.role}]`;
+        output.info(`  ${isEffective ? '>' : ' '} ${team.name} ${roleStr} - ${team.plan}${suffix}`);
+        output.info(`      ID: ${team.id}`);
+    }
+    if (envTeamId) {
+        output.info(`\nNote: ${TEAM_ID_ENV_VAR} is set, overriding session team.`);
+    }
+    if (teams.length > 1) {
+        output.info('\nUse `bellwether teams switch <team-id>` to change active team.');
+    }
+});
+// Subcommand: switch
+teamsCommand
+    .command('switch [team-id]')
+    .description('Switch to a different team')
+    .action(async (teamIdArg) => {
+    const session = getStoredSession();
+    if (!session) {
+        output.error('Not logged in.');
+        output.error('Run `bellwether login` first.');
+        process.exit(EXIT_CODES.ERROR);
+    }
+    const teams = getSessionTeams();
+    if (teams.length === 0) {
+        output.warn('No teams found in session.');
+        output.info('Try logging out and back in: `bellwether login --logout && bellwether login`');
+        return;
+    }
+    if (teams.length === 1) {
+        output.info(`You only have access to one team: ${teams[0].name}`);
+        return;
+    }
+    const targetTeamId = teamIdArg;
+    // If no team ID provided, show interactive selection
+    if (!targetTeamId) {
+        output.info('Select a team:\n');
+        for (let i = 0; i < teams.length; i++) {
+            const team = teams[i];
+            const isActive = team.id === session.activeTeamId;
+            const marker = isActive ? ' (current)' : '';
+            output.info(`  ${i + 1}. ${team.name} [${team.role}]${marker}`);
+            output.info(`     ID: ${team.id}`);
+        }
+        output.info('\nRun `bellwether teams switch <team-id>` with a team ID from above.');
+        return;
+    }
+    // Find the target team
+    const targetTeam = teams.find(t => t.id === targetTeamId || t.name.toLowerCase() === targetTeamId.toLowerCase());
+    if (!targetTeam) {
+        output.error(`Team not found: ${targetTeamId}`);
+        output.error('\nAvailable teams:');
+        for (const team of teams) {
+            output.error(`  - ${team.name} (${team.id})`);
+        }
+        process.exit(EXIT_CODES.ERROR);
+    }
+    // Check if already active
+    if (targetTeam.id === session.activeTeamId) {
+        output.info(`Already using team: ${targetTeam.name}`);
+        return;
+    }
+    // Switch team
+    const success = setActiveTeam(targetTeam.id);
+    if (success) {
+        output.info(`Switched to team: ${targetTeam.name}`);
+        output.info(`\nAll cloud commands will now use this team context.`);
+        // Warn about env var override
+        const envTeamId = process.env[TEAM_ID_ENV_VAR];
+        if (envTeamId && envTeamId !== targetTeam.id) {
+            output.warn(`\nNote: ${TEAM_ID_ENV_VAR} is set and will override this selection.`);
+            output.warn(`Unset it with: unset ${TEAM_ID_ENV_VAR}`);
+        }
+    }
+    else {
+        output.error('Failed to switch team. Please try logging in again.');
+        process.exit(EXIT_CODES.ERROR);
+    }
+});
+// Subcommand: current
+teamsCommand
+    .command('current')
+    .description('Show the current active team')
+    .option('--json', 'Output as JSON')
+    .action(async (options) => {
+    const session = getStoredSession();
+    if (!session) {
+        output.error('Not logged in.');
+        process.exit(EXIT_CODES.ERROR);
+    }
+    const effectiveTeamId = getTeamId();
+    const envTeamId = process.env[TEAM_ID_ENV_VAR];
+    const teams = getSessionTeams();
+    const activeTeam = teams.find(t => t.id === effectiveTeamId);
+    if (options.json) {
+        output.info(JSON.stringify({
+            team: activeTeam || null,
+            source: envTeamId ? 'environment' : 'session',
+            envVar: envTeamId || null,
+        }, null, 2));
+        return;
+    }
+    if (!activeTeam) {
+        output.warn('No active team.');
+        if (teams.length > 0) {
+            output.info('Run `bellwether teams switch` to select a team.');
+        }
+        else {
+            output.info('Try logging out and back in: `bellwether login --logout && bellwether login`');
+        }
+        return;
+    }
+    output.info(`Current team: ${activeTeam.name}`);
+    output.info(`  ID:   ${activeTeam.id}`);
+    output.info(`  Role: ${activeTeam.role}`);
+    output.info(`  Plan: ${activeTeam.plan}`);
+    if (envTeamId) {
+        output.info(`\nSource: ${TEAM_ID_ENV_VAR} environment variable`);
+    }
+});
+//# sourceMappingURL=teams.js.map

package/dist/cli/commands/cloud/upload.d.ts

@@ -0,0 +1,8 @@
+/**
+ * Upload command for uploading baselines to Bellwether Cloud.
+ *
+ * Can read baseline path from bellwether.yaml config.
+ */
+import { Command } from 'commander';
+export declare const uploadCommand: Command;
+//# sourceMappingURL=upload.d.ts.map

package/dist/cli/commands/cloud/upload.js

@@ -0,0 +1,181 @@
+/**
+ * Upload command for uploading baselines to Bellwether Cloud.
+ *
+ * Can read baseline path from bellwether.yaml config.
+ */
+import { Command } from 'commander';
+import { existsSync, readFileSync } from 'fs';
+import { join } from 'path';
+import { getLinkedProject } from '../../../cloud/auth.js';
+import { loadBaseline } from '../../../baseline/saver.js';
+import { convertToCloudBaseline } from '../../../baseline/converter.js';
+import { EXIT_CODES } from '../../../constants.js';
+import * as output from '../../output.js';
+import { getSeverityIcon } from '../../output.js';
+import { loadConfigOrExit, getSessionTokenOrExit, createAuthenticatedClient } from './shared.js';
+function resolveBaselinePath(pathValue, outputDir) {
+    return pathValue.startsWith('/') ? pathValue : join(outputDir, pathValue);
+}
+export const uploadCommand = new Command('upload')
+    .description('Upload a baseline to Bellwether Cloud')
+    .argument('[baseline]', 'Path to baseline JSON file (defaults to baseline.path in config)')
+    .option('-b, --baseline <path>', 'Path to baseline JSON file')
+    .option('-c, --config <path>', 'Path to config file')
+    .option('-p, --project <id>', 'Project ID to upload to (uses linked project if not specified)')
+    .option('--ci', 'CI mode - output URL only, exit 1 on breaking drift')
+    .option('--session <session>', 'Session token (overrides stored/env session)')
+    .option('--fail-on-drift', 'Exit with error if any behavioral drift detected')
+    .action(async (baselineArg, options) => {
+    // Get config settings
+    const config = loadConfigOrExit(options.config);
+    const outputDir = config.output.dir;
+    // Determine baseline path with priority:
+    // 1. Positional argument
+    // 2. --baseline flag
+    // 3. baseline.path from config
+    let baselinePath = baselineArg ?? options.baseline;
+    if (!baselinePath) {
+        baselinePath = resolveBaselinePath(config.baseline.path, outputDir);
+    }
+    const isCiMode = options.ci;
+    // Get session
+    const sessionToken = getSessionTokenOrExit(options.session, isCiMode ? 'BELLWETHER_SESSION not set' : 'Not authenticated. Run `bellwether login` first or set BELLWETHER_SESSION.');
+    // Check baseline file exists
+    if (!existsSync(baselinePath)) {
+        if (isCiMode) {
+            output.error(`Baseline not found: ${baselinePath}`);
+            process.exit(EXIT_CODES.ERROR);
+        }
+        output.error(`Baseline file not found: ${baselinePath}`);
+        output.error('\nCreate a baseline first:');
+        output.error('  1. Run `bellwether check` (with output.format: json in config)');
+        output.error('  2. Run `bellwether baseline save`');
+        process.exit(EXIT_CODES.ERROR);
+    }
+    // Determine project ID
+    let projectId = options.project;
+    if (!projectId) {
+        const link = getLinkedProject();
+        if (link) {
+            projectId = link.projectId;
+            if (!isCiMode) {
+                output.info(`Using linked project: ${link.projectName}`);
+            }
+        }
+    }
+    if (!projectId) {
+        if (isCiMode) {
+            output.error('No project specified');
+            process.exit(EXIT_CODES.ERROR);
+        }
+        output.error('No project specified.');
+        output.error('\nEither:');
+        output.error('  - Use --project <id> to specify a project');
+        output.error('  - Run `bellwether link` to link this directory to a project');
+        process.exit(EXIT_CODES.ERROR);
+    }
+    // Load and convert baseline
+    let cloudBaseline;
+    try {
+        // Try loading as cloud baseline first
+        const content = readFileSync(baselinePath, 'utf-8');
+        const parsed = JSON.parse(content);
+        if (parsed.version === '1.0' && parsed.metadata?.formatVersion === '1.0') {
+            // Already in cloud format
+            cloudBaseline = parsed;
+        }
+        else {
+            // Convert from local format
+            const localBaseline = loadBaseline(baselinePath);
+            cloudBaseline = convertToCloudBaseline(localBaseline);
+        }
+    }
+    catch (error) {
+        if (isCiMode) {
+            output.error(`Failed to load baseline: ${error instanceof Error ? error.message : error}`);
+            process.exit(EXIT_CODES.ERROR);
+        }
+        output.error('Failed to load baseline: ' + (error instanceof Error ? error.message : String(error)));
+        process.exit(EXIT_CODES.ERROR);
+    }
+    // Create client and upload
+    const client = createAuthenticatedClient(sessionToken, isCiMode ? 'Authentication failed' : 'Authentication failed. Run `bellwether login` to re-authenticate.');
+    if (!isCiMode) {
+        output.info(`Uploading baseline to project ${projectId}...`);
+    }
+    try {
+        const result = await client.uploadBaseline(projectId, cloudBaseline);
+        if (isCiMode) {
+            // CI mode - minimal output
+            output.info(result.viewUrl);
+            // Check for drift
+            if (result.version > 1) {
+                const diff = await client.getLatestDiff(projectId);
+                if (diff) {
+                    if (diff.severity === 'breaking') {
+                        output.error('Breaking changes detected');
+                        process.exit(EXIT_CODES.ERROR);
+                    }
+                    if (options.failOnDrift && diff.severity !== 'none') {
+                        output.error(`Behavioral drift detected: ${diff.severity}`);
+                        process.exit(EXIT_CODES.ERROR);
+                    }
+                }
+            }
+        }
+        else {
+            // Interactive mode - detailed output
+            output.info(`\nUpload successful!`);
+            output.info(`Version: ${result.version}`);
+            output.info(`View:    ${result.viewUrl}`);
+            if (result.diffUrl) {
+                output.info(`Diff:    ${result.diffUrl}`);
+                // Show diff summary
+                const diff = await client.getLatestDiff(projectId);
+                if (diff) {
+                    output.info('\nChanges from previous version:');
+                    printDiffSummary(diff);
+                    if (diff.severity === 'breaking') {
+                        output.info('\n⚠️  Breaking changes detected!');
+                    }
+                }
+            }
+            else {
+                output.info('\nThis is the first baseline for this project.');
+            }
+        }
+    }
+    catch (error) {
+        if (isCiMode) {
+            output.error(`Upload failed: ${error instanceof Error ? error.message : error}`);
+            process.exit(EXIT_CODES.ERROR);
+        }
+        output.error('Upload failed: ' + (error instanceof Error ? error.message : String(error)));
+        process.exit(EXIT_CODES.ERROR);
+    }
+});
+/**
+ * Print a diff summary in human-readable format (verbose format).
+ */
+function printDiffSummary(diff) {
+    output.info(`  Severity: ${getSeverityIcon(diff.severity)} ${diff.severity}`);
+    if (diff.toolsAdded > 0) {
+        output.info(`  Tools added: +${diff.toolsAdded}`);
+    }
+    if (diff.toolsRemoved > 0) {
+        output.info(`  Tools removed: -${diff.toolsRemoved}`);
+    }
+    if (diff.toolsModified > 0) {
+        output.info(`  Tools modified: ~${diff.toolsModified}`);
+    }
+    if (diff.behaviorChanges > 0) {
+        output.info(`  Behavior changes: ${diff.behaviorChanges}`);
+    }
+    if (diff.toolsAdded === 0 &&
+        diff.toolsRemoved === 0 &&
+        diff.toolsModified === 0 &&
+        diff.behaviorChanges === 0) {
+        output.info('  No changes detected');
+    }
+}
+//# sourceMappingURL=upload.js.map

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

@@ -0,0 +1,11 @@
+/**
+ * Contract commands - validate MCP servers against contracts.
+ *
+ * Subcommands:
+ *   - validate [path]     Validate server against a contract file
+ *   - generate [path]     Generate a contract from current server state
+ *   - show [path]         Display contract contents
+ */
+import { Command } from 'commander';
+export declare const contractCommand: Command;
+//# sourceMappingURL=contract.d.ts.map

package/dist/cli/commands/contract.js

@@ -0,0 +1,280 @@
+/**
+ * Contract commands - validate MCP servers against contracts.
+ *
+ * Subcommands:
+ *   - validate [path]     Validate server against a contract file
+ *   - generate [path]     Generate a contract from current server state
+ *   - show [path]         Display contract contents
+ */
+import { Command } from 'commander';
+import { existsSync, writeFileSync, readFileSync } from 'fs';
+import { join } from 'path';
+import { loadContract, findContractFile, validateContract, generateContract, generateContractYaml, generateContractValidationMarkdown, } from '../../contract/index.js';
+import { MCPClient } from '../../transport/mcp-client.js';
+import { discover } from '../../discovery/discovery.js';
+import { EXIT_CODES, CONTRACT_TESTING } from '../../constants.js';
+import { loadConfig, ConfigNotFoundError } from '../../config/loader.js';
+import * as output from '../output.js';
+/**
+ * Default paths for contract files.
+ */
+const DEFAULT_CONTRACT_FILENAMES = CONTRACT_TESTING.CONTRACT_FILENAMES;
+function loadConfigOrExit(configPath) {
+    try {
+        return loadConfig(configPath);
+    }
+    catch (error) {
+        if (error instanceof ConfigNotFoundError) {
+            output.error(error.message);
+            process.exit(EXIT_CODES.ERROR);
+        }
+        throw error;
+    }
+}
+/**
+ * Find or use provided contract path.
+ */
+function resolveContractPath(providedPath, baseDir) {
+    if (providedPath) {
+        const fullPath = providedPath.startsWith('/')
+            ? providedPath
+            : join(baseDir || '.', providedPath);
+        if (existsSync(fullPath)) {
+            return fullPath;
+        }
+        return null;
+    }
+    // Try default filenames
+    return findContractFile(baseDir || '.');
+}
+export const contractCommand = new Command('contract')
+    .description('Validate MCP servers against contract definitions')
+    .addHelpText('after', `
+Examples:
+  $ bellwether contract validate npx @mcp/server  # Validate against contract
+  $ bellwether contract generate npx @mcp/server  # Generate contract from server
+  $ bellwether contract show                       # Show current contract
+  $ bellwether contract validate npx @mcp/server --contract ./my-contract.yaml
+`);
+// contract validate
+contractCommand
+    .command('validate')
+    .description('Validate an MCP server against a contract file')
+    .argument('<server-command...>', 'MCP server command and arguments')
+    .option('-c, --config <path>', 'Path to config file')
+    .option('--contract <path>', 'Path to contract file (default: bellwether-contract.yaml)')
+    .option('--mode <mode>', 'Validation mode: strict, lenient, report')
+    .option('--fail-on-violation', 'Exit with error if violations detected (default in CI)')
+    .option('--format <format>', 'Output format: text, json, markdown')
+    .option('--timeout <ms>', 'Server startup timeout in milliseconds')
+    .action(async (serverCmd, options) => {
+    const config = loadConfigOrExit(options.config);
+    const outputDir = config.output.dir;
+    const defaultContractPath = config.contract.path;
+    const mode = (options.mode ?? config.contract.mode);
+    const format = options.format ?? config.contract.format;
+    const timeout = parseInt(options.timeout ?? String(config.contract.timeout), 10);
+    // Find contract file
+    const contractPath = resolveContractPath(options.contract ?? defaultContractPath, outputDir);
+    if (!contractPath) {
+        output.error('Contract file not found.');
+        output.error('');
+        output.error('Create a contract file by running:');
+        output.error('  bellwether contract generate <server-command>');
+        output.error('');
+        output.error(`Expected filenames: ${DEFAULT_CONTRACT_FILENAMES.join(', ')}`);
+        process.exit(EXIT_CODES.ERROR);
+    }
+    // Load contract
+    let contract;
+    try {
+        contract = loadContract(contractPath);
+    }
+    catch (error) {
+        output.error(`Failed to load contract: ${error instanceof Error ? error.message : error}`);
+        process.exit(EXIT_CODES.ERROR);
+    }
+    output.info(`Loading contract: ${contractPath}`);
+    output.info(`Validating against: ${serverCmd.join(' ')}`);
+    output.newline();
+    // Start MCP server
+    const mcpClient = new MCPClient({
+        timeout,
+        debug: false,
+        transport: 'stdio',
+    });
+    try {
+        // Parse server command
+        const command = serverCmd[0];
+        const args = serverCmd.slice(1);
+        await mcpClient.connect(command, args);
+        // Discover capabilities
+        const discovery = await discover(mcpClient, command, args);
+        // Validate against contract
+        const result = await validateContract(contract, discovery.tools, {
+            mode,
+        });
+        // Output results
+        switch (format) {
+            case 'json':
+                console.log(JSON.stringify(result, null, 2));
+                break;
+            case 'markdown':
+                console.log(generateContractValidationMarkdown(result));
+                break;
+            default:
+                // Text format
+                if (result.passed) {
+                    output.success('Contract validation PASSED');
+                }
+                else {
+                    output.error('Contract validation FAILED');
+                }
+                output.newline();
+                output.info(`Mode: ${result.mode}`);
+                output.info(`Tools checked: ${result.summary.toolsChecked}`);
+                output.info(`Tools passed: ${result.summary.toolsPassed}`);
+                output.info(`Violations: ${result.summary.totalViolations}`);
+                if (result.violations.length > 0) {
+                    output.newline();
+                    output.info('Violations:');
+                    // Group by severity
+                    const breaking = result.violations.filter(v => v.severity === 'breaking');
+                    const warnings = result.violations.filter(v => v.severity === 'warning');
+                    const infos = result.violations.filter(v => v.severity === 'info');
+                    for (const v of breaking) {
+                        output.error(`  [BREAKING] ${v.tool || v.type}: ${v.message}`);
+                    }
+                    for (const v of warnings) {
+                        output.warn(`  [WARNING] ${v.tool || v.type}: ${v.message}`);
+                    }
+                    for (const v of infos.slice(0, 5)) {
+                        output.info(`  [INFO] ${v.tool || v.type}: ${v.message}`);
+                    }
+                    if (infos.length > 5) {
+                        output.info(`  ... and ${infos.length - 5} more info violations`);
+                    }
+                }
+        }
+        // Exit with appropriate code
+        const failOnViolation = options.failOnViolation ? true : (config.contract.failOnViolation ?? !!process.env.CI);
+        if (!result.passed && failOnViolation) {
+            process.exit(EXIT_CODES.BREAKING);
+        }
+    }
+    catch (error) {
+        output.error(`Validation failed: ${error instanceof Error ? error.message : error}`);
+        process.exit(EXIT_CODES.ERROR);
+    }
+    finally {
+        await mcpClient.disconnect();
+    }
+});
+// contract generate
+contractCommand
+    .command('generate')
+    .description('Generate a contract file from current server state')
+    .argument('<server-command...>', 'MCP server command and arguments')
+    .option('-c, --config <path>', 'Path to config file')
+    .option('-o, --output <path>', 'Output path for contract file')
+    .option('--timeout <ms>', 'Server startup timeout in milliseconds')
+    .option('-f, --force', 'Overwrite existing contract file')
+    .action(async (serverCmd, options) => {
+    const config = loadConfigOrExit(options.config);
+    const outputDir = config.output.dir;
+    const defaultOutput = config.contract.path ?? DEFAULT_CONTRACT_FILENAMES[0];
+    const outputOption = options.output ?? defaultOutput;
+    const outputPath = outputOption.startsWith('/')
+        ? outputOption
+        : join(outputDir, outputOption);
+    const timeout = parseInt(options.timeout ?? String(config.contract.timeout), 10);
+    // Check for existing file
+    if (existsSync(outputPath) && !options.force) {
+        output.error(`Contract file already exists: ${outputPath}`);
+        output.error('Use --force to overwrite.');
+        process.exit(EXIT_CODES.ERROR);
+    }
+    output.info(`Generating contract from: ${serverCmd.join(' ')}`);
+    // Start MCP server
+    const mcpClient = new MCPClient({
+        timeout,
+        debug: false,
+        transport: 'stdio',
+    });
+    try {
+        // Parse server command
+        const command = serverCmd[0];
+        const args = serverCmd.slice(1);
+        await mcpClient.connect(command, args);
+        // Discover capabilities
+        const discovery = await discover(mcpClient, command, args);
+        // Generate contract
+        const serverName = discovery.serverInfo?.name || 'MCP Server';
+        const contract = generateContract(discovery.tools, serverName);
+        const yaml = generateContractYaml(contract);
+        // Write to file
+        writeFileSync(outputPath, yaml);
+        output.success(`Contract generated: ${outputPath}`);
+        output.newline();
+        output.info(`  Server: ${serverName}`);
+        output.info(`  Tools: ${discovery.tools.length}`);
+        output.info(`  Parameters: ${countParameters(contract)}`);
+    }
+    catch (error) {
+        output.error(`Generation failed: ${error instanceof Error ? error.message : error}`);
+        process.exit(EXIT_CODES.ERROR);
+    }
+    finally {
+        await mcpClient.disconnect();
+    }
+});
+// contract show
+contractCommand
+    .command('show')
+    .description('Display contract file contents')
+    .argument('[path]', 'Path to contract file')
+    .option('-c, --config <path>', 'Path to config file')
+    .option('--json', 'Output as JSON instead of YAML')
+    .action(async (contractPath, options) => {
+    const config = loadConfigOrExit(options.config);
+    const outputDir = config.output.dir;
+    const path = resolveContractPath(contractPath ?? config.contract.path, outputDir);
+    if (!path) {
+        output.error('Contract file not found.');
+        output.error(`Expected filenames: ${DEFAULT_CONTRACT_FILENAMES.join(', ')}`);
+        process.exit(EXIT_CODES.ERROR);
+    }
+    try {
+        const contract = loadContract(path);
+        output.info(`Contract: ${path}`);
+        output.info(`Version: ${contract.version}`);
+        if (contract.server?.name) {
+            output.info(`Server: ${contract.server.name}`);
+        }
+        output.newline();
+        if (options.json) {
+            console.log(JSON.stringify(contract, null, 2));
+        }
+        else {
+            const content = readFileSync(path, 'utf-8');
+            console.log(content);
+        }
+    }
+    catch (error) {
+        output.error(`Failed to load contract: ${error instanceof Error ? error.message : error}`);
+        process.exit(EXIT_CODES.ERROR);
+    }
+});
+/**
+ * Count total parameters in a contract.
+ */
+function countParameters(contract) {
+    let count = 0;
+    for (const toolContract of Object.values(contract.tools)) {
+        if (toolContract.input) {
+            count += Object.keys(toolContract.input).length;
+        }
+    }
+    return count;
+}
+//# sourceMappingURL=contract.js.map

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

@@ -0,0 +1,3 @@
+import { Command } from 'commander';
+export declare const discoverCommand: Command;
+//# sourceMappingURL=discover.d.ts.map