@contractual/cli 0.1.0-dev.0

package/dist/commands/init.command.d.ts

@@ -0,0 +1,21 @@
+import { type PromptOptions } from '../utils/prompts.js';
+import type { VersioningMode } from '@contractual/types';
+/**
+ * Options for the init command
+ */
+interface InitOptions extends PromptOptions {
+    /** Initial version for contracts */
+    initialVersion?: string;
+    /** Versioning mode */
+    versioning?: VersioningMode;
+    /** Force reinitialize */
+    force?: boolean;
+}
+/**
+ * Initialize Contractual in a repository
+ *
+ * Scans for spec files and generates contractual.yaml configuration
+ */
+export declare function initCommand(options?: InitOptions): Promise<void>;
+export {};
+//# sourceMappingURL=init.command.d.ts.map

package/dist/commands/init.command.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"init.command.d.ts","sourceRoot":"","sources":["../../src/commands/init.command.ts"],"names":[],"mappings":"AAaA,OAAO,EAML,KAAK,aAAa,EACnB,MAAM,qBAAqB,CAAC;AAC7B,OAAO,KAAK,EAAoC,cAAc,EAAE,MAAM,oBAAoB,CAAC;AAY3F;;GAEG;AACH,UAAU,WAAY,SAAQ,aAAa;IACzC,oCAAoC;IACpC,cAAc,CAAC,EAAE,MAAM,CAAC;IACxB,sBAAsB;IACtB,UAAU,CAAC,EAAE,cAAc,CAAC;IAC5B,yBAAyB;IACzB,KAAK,CAAC,EAAE,OAAO,CAAC;CACjB;AAiGD;;;;GAIG;AACH,wBAAsB,WAAW,CAAC,OAAO,GAAE,WAAgB,GAAG,OAAO,CAAC,IAAI,CAAC,CAyJ1E"}

package/dist/commands/init.command.js

@@ -0,0 +1,294 @@
+import { existsSync, writeFileSync, readFileSync } from 'node:fs';
+import { join, basename } from 'node:path';
+import fg from 'fast-glob';
+import chalk from 'chalk';
+import ora from 'ora';
+import { parse as parseYaml, stringify as stringifyYaml } from 'yaml';
+import { VersionManager } from '@contractual/changesets';
+import { ensureContractualDir, detectSpecType, CONTRACTUAL_DIR, getSnapshotPath, } from '../utils/files.js';
+import { promptSelect, promptVersion, promptConfirm, VERSION_CHOICES, VERSIONING_MODE_CHOICES, } from '../utils/prompts.js';
+/**
+ * Default starting version for new contracts
+ */
+const DEFAULT_VERSION = '0.0.0';
+/**
+ * Default versioning mode
+ */
+const DEFAULT_VERSIONING_MODE = 'independent';
+/**
+ * Glob patterns to find spec files
+ */
+const SPEC_PATTERNS = [
+    '**/*.openapi.yaml',
+    '**/*.openapi.yml',
+    '**/*.openapi.json',
+    '**/openapi.yaml',
+    '**/openapi.yml',
+    '**/openapi.json',
+    '**/*.asyncapi.yaml',
+    '**/*.asyncapi.yml',
+    '**/*.asyncapi.json',
+    '**/*.schema.json',
+    '**/*.odcs.yaml',
+    '**/*.odcs.yml',
+];
+/**
+ * Directories to ignore when scanning
+ */
+const IGNORE_PATTERNS = [
+    '**/node_modules/**',
+    '**/.git/**',
+    '**/dist/**',
+    '**/build/**',
+    '**/.contractual/**',
+];
+/**
+ * Extract contract name from file path
+ * Uses the filename stem without extension patterns
+ */
+function extractContractName(filePath) {
+    const base = basename(filePath);
+    // Remove known suffixes and extensions
+    let name = base
+        .replace(/\.openapi\.(ya?ml|json)$/i, '')
+        .replace(/\.asyncapi\.(ya?ml|json)$/i, '')
+        .replace(/\.schema\.json$/i, '')
+        .replace(/\.odcs\.ya?ml$/i, '')
+        .replace(/\.(ya?ml|json)$/i, '');
+    // Handle generic names like "openapi" -> use parent directory name
+    if (['openapi', 'asyncapi', 'schema', 'spec', 'api'].includes(name.toLowerCase())) {
+        const parts = filePath.split('/');
+        if (parts.length >= 2) {
+            name = parts[parts.length - 2];
+        }
+    }
+    return name;
+}
+/**
+ * Get initial version through prompts or options
+ */
+async function getInitialVersion(options) {
+    // If version provided via CLI, use it
+    if (options.initialVersion) {
+        return options.initialVersion;
+    }
+    // Prompt for version
+    const versionChoice = await promptSelect('Initial version for contracts:', [...VERSION_CHOICES], '0.0.0', options);
+    if (versionChoice === 'custom') {
+        return promptVersion('Enter version:', DEFAULT_VERSION, options);
+    }
+    return versionChoice;
+}
+/**
+ * Get versioning mode through prompts or options
+ */
+async function getVersioningMode(options) {
+    if (options.versioning) {
+        return options.versioning;
+    }
+    return promptSelect('Versioning mode:', [...VERSIONING_MODE_CHOICES], DEFAULT_VERSIONING_MODE, options);
+}
+/**
+ * Initialize Contractual in a repository
+ *
+ * Scans for spec files and generates contractual.yaml configuration
+ */
+export async function initCommand(options = {}) {
+    const cwd = process.cwd();
+    const configPath = join(cwd, 'contractual.yaml');
+    const contractualDir = join(cwd, CONTRACTUAL_DIR);
+    // Check if already initialized
+    if (existsSync(configPath) && !options.force) {
+        // Try to handle existing project with uninitialized contracts
+        await handleExistingProject(cwd, configPath, contractualDir, options);
+        return;
+    }
+    const spinner = ora('Scanning for spec files...').start();
+    try {
+        // Scan for spec files
+        const files = await fg(SPEC_PATTERNS, {
+            cwd,
+            ignore: IGNORE_PATTERNS,
+            absolute: false,
+            onlyFiles: true,
+        });
+        spinner.succeed(`Found ${files.length} potential spec file(s)`);
+        // Build contract definitions
+        const contracts = [];
+        const seenNames = new Set();
+        for (const filePath of files) {
+            const absolutePath = join(cwd, filePath);
+            const detectedType = detectSpecType(absolutePath);
+            if (!detectedType) {
+                continue;
+            }
+            let name = extractContractName(filePath);
+            // Ensure unique names
+            if (seenNames.has(name)) {
+                let counter = 2;
+                while (seenNames.has(`${name}-${counter}`)) {
+                    counter++;
+                }
+                name = `${name}-${counter}`;
+            }
+            seenNames.add(name);
+            contracts.push({
+                name,
+                type: detectedType,
+                path: filePath,
+            });
+        }
+        if (contracts.length === 0) {
+            console.log(chalk.yellow('\nNo spec files found'));
+            console.log(chalk.dim('\nSupported file patterns:'));
+            console.log(chalk.dim('  - *.openapi.yaml/json'));
+            console.log(chalk.dim('  - *.asyncapi.yaml/json'));
+            console.log(chalk.dim('  - *.schema.json'));
+            console.log(chalk.dim('  - *.odcs.yaml'));
+            console.log(chalk.dim('\nYou can manually create contractual.yaml to define contracts.'));
+            return;
+        }
+        // Show found contracts
+        console.log();
+        for (const contract of contracts) {
+            const typeColor = getTypeColor(contract.type);
+            console.log(`  ${chalk.dim('Found:')} ${contract.path} ${chalk.dim('(')}${typeColor(contract.type)}${chalk.dim(')')}`);
+        }
+        console.log();
+        // Get version and mode through prompts
+        const initialVersion = await getInitialVersion(options);
+        const versioningMode = await getVersioningMode(options);
+        // Generate config
+        const config = {
+            contracts,
+            changeset: {
+                autoDetect: true,
+                requireOnPR: true,
+            },
+        };
+        // Only add versioning section if not using defaults
+        if (versioningMode !== 'independent') {
+            config.versioning = {
+                mode: versioningMode,
+            };
+        }
+        // Write contractual.yaml
+        const yamlContent = stringifyYaml(config, {
+            lineWidth: 100,
+            singleQuote: true,
+        });
+        writeFileSync(configPath, yamlContent, 'utf-8');
+        // Create .contractual directory structure
+        const createdDir = ensureContractualDir(cwd);
+        // Create snapshots and set initial versions
+        const versionManager = new VersionManager(createdDir);
+        for (const contract of contracts) {
+            const absolutePath = join(cwd, contract.path);
+            versionManager.setVersion(contract.name, initialVersion, absolutePath);
+        }
+        // Print summary
+        console.log();
+        console.log(chalk.green('✓') + ' Initialized Contractual');
+        console.log();
+        console.log(chalk.bold('Created:'));
+        console.log(`  ${chalk.green('+')} contractual.yaml`);
+        console.log(`  ${chalk.green('+')} .contractual/`);
+        console.log(`  ${chalk.green('+')} .contractual/changesets/`);
+        console.log(`  ${chalk.green('+')} .contractual/snapshots/`);
+        console.log(`  ${chalk.green('+')} .contractual/versions.json`);
+        console.log();
+        console.log(chalk.bold(`Detected ${contracts.length} contract(s) at v${initialVersion}:`));
+        for (const contract of contracts) {
+            const typeColor = getTypeColor(contract.type);
+            console.log(`  ${chalk.cyan(contract.name)} ${chalk.dim('(')}${typeColor(contract.type)}${chalk.dim(')')}`);
+            console.log(`    ${chalk.dim(contract.path)}`);
+        }
+        if (versioningMode !== 'independent') {
+            console.log();
+            console.log(chalk.dim(`Versioning mode: ${versioningMode}`));
+        }
+        console.log();
+        console.log(chalk.dim('Next steps:'));
+        console.log(chalk.dim('  1. Run `contractual lint` to validate your specs'));
+        console.log(chalk.dim('  2. Make changes to your specs'));
+        console.log(chalk.dim('  3. Run `contractual diff` to see changes'));
+        console.log(chalk.dim('  4. Run `contractual changeset` to record changes'));
+    }
+    catch (error) {
+        spinner.fail('Initialization failed');
+        const message = error instanceof Error ? error.message : 'Unknown error';
+        console.error(chalk.red(message));
+        process.exitCode = 1;
+    }
+}
+/**
+ * Handle existing project - initialize uninitialized contracts
+ */
+async function handleExistingProject(cwd, configPath, contractualDir, options) {
+    // Read existing config
+    const configContent = readFileSync(configPath, 'utf-8');
+    const config = parseYaml(configContent);
+    if (!config.contracts || config.contracts.length === 0) {
+        console.log(chalk.red('Already initialized:') + ' contractual.yaml exists');
+        console.log(chalk.dim('Use `contractual status` to see current state'));
+        process.exitCode = 1;
+        return;
+    }
+    // Ensure .contractual directory exists
+    ensureContractualDir(cwd);
+    // Find contracts without snapshots
+    const uninitializedContracts = [];
+    for (const contract of config.contracts) {
+        const snapshotPath = getSnapshotPath(contract.name, contractualDir);
+        if (!snapshotPath) {
+            uninitializedContracts.push(contract);
+        }
+    }
+    if (uninitializedContracts.length === 0) {
+        console.log(chalk.yellow('Already initialized:') + ' contractual.yaml exists');
+        console.log(chalk.dim('All contracts have snapshots.'));
+        console.log(chalk.dim('Use `contractual status` to see current state'));
+        console.log(chalk.dim('Use `--force` to reinitialize'));
+        return;
+    }
+    // Show uninitialized contracts
+    console.log(chalk.yellow(`Found ${uninitializedContracts.length} contract(s) without version history:`));
+    for (const contract of uninitializedContracts) {
+        console.log(`  ${chalk.dim('-')} ${chalk.cyan(contract.name)} ${chalk.dim(`(${contract.type})`)}`);
+    }
+    console.log();
+    // Confirm initialization
+    const shouldInitialize = await promptConfirm(`Initialize with version ${DEFAULT_VERSION}?`, true, options);
+    if (!shouldInitialize) {
+        console.log(chalk.dim('Skipped initialization'));
+        return;
+    }
+    // Initialize uninitialized contracts
+    const versionManager = new VersionManager(contractualDir);
+    for (const contract of uninitializedContracts) {
+        const absolutePath = join(cwd, contract.path);
+        if (!existsSync(absolutePath)) {
+            console.log(chalk.yellow(`  Skipped ${contract.name}: spec file not found at ${contract.path}`));
+            continue;
+        }
+        versionManager.setVersion(contract.name, DEFAULT_VERSION, absolutePath);
+        console.log(chalk.green('✓') + ` Initialized ${chalk.cyan(contract.name)} at v${DEFAULT_VERSION}`);
+    }
+}
+/**
+ * Get chalk color function for contract type
+ */
+function getTypeColor(type) {
+    switch (type) {
+        case 'openapi':
+            return chalk.green;
+        case 'asyncapi':
+            return chalk.magenta;
+        case 'json-schema':
+            return chalk.blue;
+        case 'odcs':
+            return chalk.yellow;
+        default:
+            return chalk.white;
+    }
+}

package/dist/commands/lint.command.d.ts

@@ -0,0 +1,16 @@
+/**
+ * Options for the lint command
+ */
+export interface LintOptions {
+    /** Filter to specific contract name */
+    contract?: string;
+    /** Output format */
+    format?: 'text' | 'json';
+    /** Exit 1 on warnings */
+    failOnWarn?: boolean;
+}
+/**
+ * Run linters for all configured contracts
+ */
+export declare function lintCommand(options?: LintOptions): Promise<void>;
+//# sourceMappingURL=lint.command.d.ts.map

package/dist/commands/lint.command.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"lint.command.d.ts","sourceRoot":"","sources":["../../src/commands/lint.command.ts"],"names":[],"mappings":"AAOA;;GAEG;AACH,MAAM,WAAW,WAAW;IAC1B,uCAAuC;IACvC,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,oBAAoB;IACpB,MAAM,CAAC,EAAE,MAAM,GAAG,MAAM,CAAC;IACzB,yBAAyB;IACzB,UAAU,CAAC,EAAE,OAAO,CAAC;CACtB;AAiCD;;GAEG;AACH,wBAAsB,WAAW,CAAC,OAAO,GAAE,WAAgB,GAAG,OAAO,CAAC,IAAI,CAAC,CA0K1E"}

package/dist/commands/lint.command.js

@@ -0,0 +1,174 @@
+import chalk from 'chalk';
+import ora from 'ora';
+import { loadConfig } from '../config/index.js';
+import { getLinter as getRegisteredLinter } from '../governance/index.js';
+import { printSuccess, printError, printWarning } from '../utils/output.js';
+/**
+ * Get linter for a contract using the governance registry
+ */
+function getLinterForContract(contract) {
+    // Check if linting is explicitly disabled
+    if (contract.lint === false) {
+        return { status: 'disabled' };
+    }
+    // Use the governance registry to get the linter
+    const linter = getRegisteredLinter(contract.type, contract.lint);
+    if (linter === null) {
+        return { status: 'disabled' };
+    }
+    if (!linter) {
+        return { status: 'not-found', type: contract.type };
+    }
+    return { status: 'found', linter };
+}
+/**
+ * Run linters for all configured contracts
+ */
+export async function lintCommand(options = {}) {
+    const { contract: filterContract, format = 'text', failOnWarn = false } = options;
+    try {
+        // Load config
+        const config = loadConfig();
+        // Filter contracts if specified
+        let contracts = config.contracts;
+        if (filterContract) {
+            contracts = contracts.filter((c) => c.name === filterContract);
+            if (contracts.length === 0) {
+                if (format === 'json') {
+                    console.log(JSON.stringify({ error: `Contract "${filterContract}" not found` }));
+                }
+                else {
+                    printError(`Contract "${filterContract}" not found`);
+                }
+                process.exitCode = 1;
+                return;
+            }
+        }
+        if (contracts.length === 0) {
+            if (format === 'json') {
+                console.log(JSON.stringify({ results: [], errors: 0, warnings: 0 }));
+            }
+            else {
+                printWarning('No contracts configured');
+            }
+            return;
+        }
+        const results = [];
+        const spinner = format === 'text' ? ora('Linting contracts...').start() : null;
+        for (const contract of contracts) {
+            if (spinner) {
+                spinner.text = `Linting ${contract.name}...`;
+            }
+            const linterResult = getLinterForContract(contract);
+            // Linting explicitly disabled
+            if (linterResult.status === 'disabled') {
+                if (format === 'text') {
+                    spinner?.stopAndPersist({
+                        symbol: chalk.dim('-'),
+                        text: `${contract.name}: ${chalk.dim('linting disabled')}`,
+                    });
+                    spinner?.start();
+                }
+                continue;
+            }
+            // No linter registered for this type
+            if (linterResult.status === 'not-found') {
+                if (format === 'text') {
+                    spinner?.stopAndPersist({
+                        symbol: chalk.yellow('!'),
+                        text: `${contract.name}: ${chalk.yellow(`no linter available for ${linterResult.type}`)}`,
+                    });
+                    spinner?.start();
+                }
+                continue;
+            }
+            try {
+                const result = await linterResult.linter(contract.absolutePath);
+                results.push({
+                    ...result,
+                    contract: contract.name,
+                });
+            }
+            catch (error) {
+                const message = error instanceof Error ? error.message : 'Linter execution failed';
+                results.push({
+                    contract: contract.name,
+                    specPath: contract.absolutePath,
+                    errors: [
+                        {
+                            path: '',
+                            message,
+                            severity: 'error',
+                        },
+                    ],
+                    warnings: [],
+                });
+            }
+        }
+        spinner?.stop();
+        // Calculate totals
+        const totalErrors = results.reduce((sum, r) => sum + r.errors.length, 0);
+        const totalWarnings = results.reduce((sum, r) => sum + r.warnings.length, 0);
+        // Output results
+        if (format === 'json') {
+            console.log(JSON.stringify({
+                results,
+                errors: totalErrors,
+                warnings: totalWarnings,
+            }, null, 2));
+        }
+        else {
+            // Text format output
+            console.log();
+            for (const result of results) {
+                const hasErrors = result.errors.length > 0;
+                const hasWarnings = result.warnings.length > 0;
+                if (!hasErrors && !hasWarnings) {
+                    printSuccess(`${result.contract}: No issues found`);
+                    continue;
+                }
+                // Print contract header
+                const errorCount = result.errors.length;
+                const warningCount = result.warnings.length;
+                const summary = [];
+                if (errorCount > 0)
+                    summary.push(chalk.red(`${errorCount} error(s)`));
+                if (warningCount > 0)
+                    summary.push(chalk.yellow(`${warningCount} warning(s)`));
+                console.log(`${chalk.bold(result.contract)}: ${summary.join(', ')}`);
+                // Print errors
+                for (const error of result.errors) {
+                    const location = error.path ? chalk.dim(`[${error.path}]`) : '';
+                    const rule = error.rule ? chalk.dim(`(${error.rule})`) : '';
+                    console.log(`  ${chalk.red('error')} ${location} ${error.message} ${rule}`);
+                }
+                // Print warnings
+                for (const warning of result.warnings) {
+                    const location = warning.path ? chalk.dim(`[${warning.path}]`) : '';
+                    const rule = warning.rule ? chalk.dim(`(${warning.rule})`) : '';
+                    console.log(`  ${chalk.yellow('warn')}  ${location} ${warning.message} ${rule}`);
+                }
+                console.log();
+            }
+            // Summary
+            if (results.length > 0) {
+                console.log(chalk.dim(`Checked ${results.length} contract(s): ` +
+                    `${totalErrors} error(s), ${totalWarnings} warning(s)`));
+            }
+        }
+        // Exit with error code if there were errors (or warnings if --fail-on-warn)
+        if (totalErrors > 0 || (failOnWarn && totalWarnings > 0)) {
+            process.exitCode = 1;
+        }
+    }
+    catch (error) {
+        const message = error instanceof Error ? error.message : 'Unknown error';
+        if (options.format === 'json') {
+            console.log(JSON.stringify({ error: message }));
+        }
+        else {
+            printError(message);
+        }
+        process.exitCode = 1;
+    }
+}

package/dist/commands/pre.command.d.ts

@@ -0,0 +1,14 @@
+/**
+ * Enter pre-release mode
+ * @param tag - The pre-release tag (e.g., "alpha", "beta", "rc")
+ */
+export declare function preEnterCommand(tag: string): Promise<void>;
+/**
+ * Exit pre-release mode
+ */
+export declare function preExitCommand(): Promise<void>;
+/**
+ * Show pre-release status
+ */
+export declare function preStatusCommand(): Promise<void>;
+//# sourceMappingURL=pre.command.d.ts.map

package/dist/commands/pre.command.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"pre.command.d.ts","sourceRoot":"","sources":["../../src/commands/pre.command.ts"],"names":[],"mappings":"AAIA;;;GAGG;AACH,wBAAsB,eAAe,CAAC,GAAG,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC,CAsChE;AAED;;GAEG;AACH,wBAAsB,cAAc,IAAI,OAAO,CAAC,IAAI,CAAC,CA+DpD;AAED;;GAEG;AACH,wBAAsB,gBAAgB,IAAI,OAAO,CAAC,IAAI,CAAC,CAoDtD"}

package/dist/commands/pre.command.js

@@ -0,0 +1,141 @@
+import chalk from 'chalk';
+import { VersionManager, PreReleaseManager } from '@contractual/changesets';
+import { findContractualDir } from '../utils/files.js';
+/**
+ * Enter pre-release mode
+ * @param tag - The pre-release tag (e.g., "alpha", "beta", "rc")
+ */
+export async function preEnterCommand(tag) {
+    const cwd = process.cwd();
+    const contractualDir = findContractualDir(cwd);
+    if (!contractualDir) {
+        console.error(chalk.red('No .contractual directory found. Run `contractual init` first.'));
+        process.exitCode = 1;
+        return;
+    }
+    try {
+        const versionManager = new VersionManager(contractualDir);
+        const preManager = new PreReleaseManager(contractualDir);
+        if (preManager.isActive()) {
+            const state = preManager.getState();
+            console.log(chalk.yellow('Already in pre-release mode:') + ` ${state?.tag}`);
+            console.log(chalk.dim('Run `contractual pre exit` to leave pre-release mode first.'));
+            process.exitCode = 1;
+            return;
+        }
+        preManager.enter(tag, versionManager);
+        console.log(chalk.green('✓') + ` Entered pre-release mode: ${chalk.cyan(tag)}`);
+        console.log();
+        console.log(chalk.bold('Created:'));
+        console.log(`  ${chalk.green('+')} .contractual/pre.json`);
+        console.log();
+        console.log(chalk.dim(`Next versions will use ${tag} identifier (e.g., 2.0.0-${tag}.0)`));
+        console.log(chalk.dim('Run `contractual version` to apply changesets with pre-release versions.'));
+    }
+    catch (error) {
+        const message = error instanceof Error ? error.message : 'Unknown error';
+        console.error(chalk.red('Failed to enter pre-release mode:'), message);
+        process.exitCode = 1;
+    }
+}
+/**
+ * Exit pre-release mode
+ */
+export async function preExitCommand() {
+    const cwd = process.cwd();
+    const contractualDir = findContractualDir(cwd);
+    if (!contractualDir) {
+        console.error(chalk.red('No .contractual directory found. Run `contractual init` first.'));
+        process.exitCode = 1;
+        return;
+    }
+    try {
+        const versionManager = new VersionManager(contractualDir);
+        const preManager = new PreReleaseManager(contractualDir);
+        if (!preManager.isActive()) {
+            console.log(chalk.yellow('Not in pre-release mode.'));
+            return;
+        }
+        const state = preManager.getState();
+        const currentVersions = versionManager.getAllVersions();
+        // Show what will change
+        console.log(chalk.bold('Exiting pre-release mode'));
+        console.log();
+        const hasPreReleaseVersions = Object.entries(currentVersions).some(([_, version]) => version.includes('-'));
+        if (hasPreReleaseVersions) {
+            console.log(chalk.dim('Current pre-release versions:'));
+            for (const [contract, version] of Object.entries(currentVersions)) {
+                if (version.includes('-')) {
+                    // Extract base version
+                    const baseVersion = version.split('-')[0];
+                    console.log(`  ${chalk.cyan(contract)}: ${chalk.gray(version)} → ${chalk.green(baseVersion)}`);
+                }
+            }
+            console.log();
+            console.log(chalk.dim('Run `contractual version` after exiting to finalize versions.'));
+        }
+        preManager.exit();
+        console.log();
+        console.log(chalk.green('✓') + ' Exited pre-release mode');
+        console.log();
+        console.log(chalk.bold('Removed:'));
+        console.log(`  ${chalk.red('-')} .contractual/pre.json`);
+        if (state) {
+            console.log();
+            console.log(chalk.dim(`Pre-release tag was: ${state.tag}`));
+            console.log(chalk.dim(`Entered at: ${new Date(state.enteredAt).toLocaleString()}`));
+        }
+    }
+    catch (error) {
+        const message = error instanceof Error ? error.message : 'Unknown error';
+        console.error(chalk.red('Failed to exit pre-release mode:'), message);
+        process.exitCode = 1;
+    }
+}
+/**
+ * Show pre-release status
+ */
+export async function preStatusCommand() {
+    const cwd = process.cwd();
+    const contractualDir = findContractualDir(cwd);
+    if (!contractualDir) {
+        console.error(chalk.red('No .contractual directory found. Run `contractual init` first.'));
+        process.exitCode = 1;
+        return;
+    }
+    const preManager = new PreReleaseManager(contractualDir);
+    if (!preManager.isActive()) {
+        console.log(chalk.dim('Not in pre-release mode.'));
+        console.log(chalk.dim('Run `contractual pre enter <tag>` to enter pre-release mode.'));
+        return;
+    }
+    const state = preManager.getState();
+    if (!state) {
+        console.log(chalk.yellow('Pre-release state file is corrupted.'));
+        console.log(chalk.dim('Run `contractual pre exit` to reset.'));
+        return;
+    }
+    const versionManager = new VersionManager(contractualDir);
+    const currentVersions = versionManager.getAllVersions();
+    console.log(chalk.bold('Pre-release Status'));
+    console.log();
+    console.log(`  ${chalk.dim('Tag:')}       ${chalk.cyan(state.tag)}`);
+    console.log(`  ${chalk.dim('Since:')}     ${new Date(state.enteredAt).toLocaleString()}`);
+    // Show version changes since entering pre-release
+    const changedContracts = Object.entries(currentVersions).filter(([name, version]) => {
+        const initial = state.initialVersions[name];
+        return initial && initial !== version;
+    });
+    if (changedContracts.length > 0) {
+        console.log();
+        console.log(chalk.bold('Version changes since entering pre-release:'));
+        for (const [name, version] of changedContracts) {
+            const initial = state.initialVersions[name];
+            console.log(`  ${chalk.cyan(name)}: ${chalk.gray(initial)} → ${chalk.green(version)}`);
+        }
+    }
+    console.log();
+    console.log(chalk.dim('Commands:'));
+    console.log(chalk.dim('  contractual version    Apply changesets with pre-release versions'));
+    console.log(chalk.dim('  contractual pre exit   Exit pre-release mode'));
+}

package/dist/commands/status.command.d.ts

@@ -0,0 +1,5 @@
+/**
+ * Show current state - versions, pending changesets, projected bumps
+ */
+export declare function statusCommand(): Promise<void>;
+//# sourceMappingURL=status.command.d.ts.map

package/dist/commands/status.command.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"status.command.d.ts","sourceRoot":"","sources":["../../src/commands/status.command.ts"],"names":[],"mappings":"AA0BA;;GAEG;AACH,wBAAsB,aAAa,IAAI,OAAO,CAAC,IAAI,CAAC,CAkHnD"}