@contractual/cli 0.1.0-dev.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (C) 2025 Omer Morad
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/bin/cli.js

@@ -0,0 +1,2 @@
+#!/usr/bin/env node
+import '../dist/commands.js';

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

@@ -0,0 +1,19 @@
+/**
+ * Breaking Command
+ *
+ * Detect breaking changes against snapshots.
+ * This is a CI gate — exits 1 if breaking changes are found.
+ *
+ * Uses the shared diffContracts() function internally.
+ */
+interface BreakingOptions {
+    contract?: string;
+    format?: 'text' | 'json';
+    failOn?: 'breaking' | 'non-breaking' | 'any';
+}
+/**
+ * Detect breaking changes against snapshots
+ */
+export declare function breakingCommand(options: BreakingOptions): Promise<void>;
+export {};
+//# sourceMappingURL=breaking.command.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"breaking.command.d.ts","sourceRoot":"","sources":["../../src/commands/breaking.command.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AASH,UAAU,eAAe;IACvB,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,MAAM,CAAC,EAAE,MAAM,GAAG,MAAM,CAAC;IACzB,MAAM,CAAC,EAAE,UAAU,GAAG,cAAc,GAAG,KAAK,CAAC;CAC9C;AAOD;;GAEG;AACH,wBAAsB,eAAe,CAAC,OAAO,EAAE,eAAe,GAAG,OAAO,CAAC,IAAI,CAAC,CAgE7E"}

package/dist/commands/breaking.command.js

@@ -0,0 +1,138 @@
+/**
+ * Breaking Command
+ *
+ * Detect breaking changes against snapshots.
+ * This is a CI gate — exits 1 if breaking changes are found.
+ *
+ * Uses the shared diffContracts() function internally.
+ */
+import chalk from 'chalk';
+import ora from 'ora';
+import { loadConfig } from '../config/index.js';
+import { diffContracts } from '../core/diff.js';
+import { formatSeverity } from '../utils/output.js';
+/**
+ * Detect breaking changes against snapshots
+ */
+export async function breakingCommand(options) {
+    const spinner = ora('Loading configuration...').start();
+    let config;
+    try {
+        config = loadConfig();
+        spinner.succeed('Configuration loaded');
+    }
+    catch (error) {
+        spinner.fail('Failed to load configuration');
+        const message = error instanceof Error ? error.message : 'Unknown error';
+        console.error(chalk.red(message));
+        process.exitCode = 1;
+        return;
+    }
+    const checkSpinner = ora('Checking for breaking changes...').start();
+    try {
+        const { results } = await diffContracts(config, {
+            contracts: options.contract ? [options.contract] : undefined,
+            includeEmpty: true,
+        });
+        const hasBreaking = results.some((r) => r.summary.breaking > 0);
+        if (hasBreaking) {
+            checkSpinner.fail('Breaking changes detected');
+        }
+        else {
+            checkSpinner.succeed('No breaking changes');
+        }
+        // Output results
+        console.log();
+        if (options.format === 'json') {
+            const output = { hasBreaking, results };
+            console.log(JSON.stringify(output, null, 2));
+        }
+        else {
+            printTextResults(results);
+        }
+        // Determine exit code based on --fail-on option
+        const failOn = options.failOn ?? 'breaking';
+        let shouldFail = false;
+        if (failOn === 'any') {
+            // Fail on any detected changes
+            shouldFail = results.some((r) => r.changes.length > 0);
+        }
+        else if (failOn === 'non-breaking') {
+            // Fail on non-breaking or breaking changes
+            shouldFail = results.some((r) => r.summary.breaking > 0 || r.summary.nonBreaking > 0);
+        }
+        else {
+            // Default: fail only on breaking changes
+            shouldFail = hasBreaking;
+        }
+        if (shouldFail) {
+            process.exitCode = 1;
+        }
+    }
+    catch (error) {
+        checkSpinner.fail('Failed to check for breaking changes');
+        const message = error instanceof Error ? error.message : 'Unknown error';
+        console.error(chalk.red('Error:'), message);
+        process.exitCode = 1;
+    }
+}
+/**
+ * Print results in human-readable text format
+ */
+function printTextResults(results) {
+    if (results.length === 0) {
+        console.log(chalk.gray('No contracts were checked.'));
+        return;
+    }
+    for (const result of results) {
+        console.log(chalk.bold.underline(result.contract));
+        console.log();
+        if (result.changes.length === 0) {
+            console.log(chalk.gray('  No changes detected.'));
+            console.log();
+            continue;
+        }
+        // Group changes by severity
+        const breaking = result.changes.filter((c) => c.severity === 'breaking');
+        const nonBreaking = result.changes.filter((c) => c.severity === 'non-breaking');
+        const patch = result.changes.filter((c) => c.severity === 'patch');
+        const unknown = result.changes.filter((c) => c.severity === 'unknown');
+        // Print summary
+        console.log(`  Summary: ` +
+            `${chalk.red(String(result.summary.breaking))} breaking, ` +
+            `${chalk.yellow(String(result.summary.nonBreaking))} non-breaking, ` +
+            `${chalk.green(String(result.summary.patch))} patch, ` +
+            `${chalk.gray(String(result.summary.unknown))} unknown`);
+        console.log(`  Suggested bump: ${chalk.cyan(result.suggestedBump)}`);
+        console.log();
+        // Print changes by severity
+        if (breaking.length > 0) {
+            console.log(`  ${formatSeverity('breaking')} Changes:`);
+            for (const change of breaking) {
+                console.log(`    - ${change.path}: ${change.message}`);
+            }
+            console.log();
+        }
+        if (nonBreaking.length > 0) {
+            console.log(`  ${formatSeverity('non-breaking')} Changes:`);
+            for (const change of nonBreaking) {
+                console.log(`    - ${change.path}: ${change.message}`);
+            }
+            console.log();
+        }
+        if (patch.length > 0) {
+            console.log(`  ${formatSeverity('patch')} Changes:`);
+            for (const change of patch) {
+                console.log(`    - ${change.path}: ${change.message}`);
+            }
+            console.log();
+        }
+        if (unknown.length > 0) {
+            console.log(`  ${formatSeverity('unknown')} Changes:`);
+            for (const change of unknown) {
+                console.log(`    - ${change.path}: ${change.message}`);
+            }
+            console.log();
+        }
+    }
+}

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

@@ -0,0 +1,11 @@
+/**
+ * Changeset Command
+ *
+ * Auto-generate changeset from detected changes.
+ * Uses the shared diffContracts() function internally.
+ */
+/**
+ * Auto-generate changeset from detected changes
+ */
+export declare function changesetCommand(): Promise<void>;
+//# sourceMappingURL=changeset.command.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"changeset.command.d.ts","sourceRoot":"","sources":["../../src/commands/changeset.command.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAeH;;GAEG;AACH,wBAAsB,gBAAgB,IAAI,OAAO,CAAC,IAAI,CAAC,CAuDtD"}

package/dist/commands/changeset.command.js

@@ -0,0 +1,65 @@
+/**
+ * Changeset Command
+ *
+ * Auto-generate changeset from detected changes.
+ * Uses the shared diffContracts() function internally.
+ */
+import { writeFileSync } from 'node:fs';
+import { join } from 'node:path';
+import chalk from 'chalk';
+import ora from 'ora';
+import { loadConfig } from '../config/index.js';
+import { diffContracts } from '../core/diff.js';
+import { CHANGESETS_DIR } from '../utils/files.js';
+import { createChangeset, generateUniqueChangesetName, readChangesets, } from '@contractual/changesets';
+/**
+ * Auto-generate changeset from detected changes
+ */
+export async function changesetCommand() {
+    const spinner = ora('Loading configuration...').start();
+    let config;
+    try {
+        config = loadConfig();
+        spinner.succeed('Configuration loaded');
+    }
+    catch (error) {
+        spinner.fail('Failed to load configuration');
+        const message = error instanceof Error ? error.message : 'Unknown error';
+        console.error(chalk.red(message));
+        process.exit(1);
+    }
+    // Detect changes for all contracts using shared diff logic
+    const diffSpinner = ora('Detecting changes...').start();
+    try {
+        const { results: diffResults, contractualDir } = await diffContracts(config, {
+            includeEmpty: false, // Only get contracts with actual changes
+        });
+        if (diffResults.length === 0) {
+            diffSpinner.succeed('No changes detected');
+            console.log(chalk.gray('No changeset created.'));
+            process.exit(0);
+        }
+        diffSpinner.succeed(`Detected changes in ${diffResults.length} contract(s)`);
+        // Create changeset content
+        const { content: changesetContent } = createChangeset(diffResults);
+        // Read existing changesets to ensure unique name
+        const changesetsDir = join(contractualDir, CHANGESETS_DIR);
+        const existingChangesets = await readChangesets(changesetsDir);
+        const existingNames = existingChangesets.map((c) => c.filename.replace(/\.md$/, ''));
+        const changesetName = generateUniqueChangesetName(existingNames);
+        // Write changeset file
+        const changesetPath = join(changesetsDir, `${changesetName}.md`);
+        writeFileSync(changesetPath, changesetContent, 'utf-8');
+        console.log();
+        console.log(chalk.green('Created changeset:'), chalk.cyan(changesetPath));
+        console.log();
+        console.log(chalk.gray('You can edit this file to add more details about the changes.'));
+        console.log(chalk.gray('Run `contractual version` to consume changesets and bump versions.'));
+    }
+    catch (error) {
+        diffSpinner.fail('Failed to detect changes');
+        const message = error instanceof Error ? error.message : 'Unknown error';
+        console.error(chalk.red('Error:'), message);
+        process.exit(1);
+    }
+}

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

@@ -0,0 +1,34 @@
+import { type PromptOptions } from '../utils/prompts.js';
+import type { ContractType } from '@contractual/types';
+/**
+ * Options for the contract add command
+ */
+interface ContractAddOptions extends PromptOptions {
+    /** Contract name */
+    name?: string;
+    /** Contract type */
+    type?: ContractType;
+    /** Path to spec file */
+    path?: string;
+    /** Initial version */
+    initialVersion?: string;
+    /** Skip validation */
+    skipValidation?: boolean;
+}
+/**
+ * Add a new contract to the configuration
+ */
+export declare function contractAddCommand(options?: ContractAddOptions): Promise<void>;
+/**
+ * Options for the contract list command
+ */
+interface ContractListOptions {
+    /** Output as JSON */
+    json?: boolean;
+}
+/**
+ * List contracts
+ */
+export declare function contractListCommand(name: string | undefined, options?: ContractListOptions): Promise<void>;
+export {};
+//# sourceMappingURL=contract.command.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"contract.command.d.ts","sourceRoot":"","sources":["../../src/commands/contract.command.ts"],"names":[],"mappings":"AAYA,OAAO,EAKL,KAAK,aAAa,EACnB,MAAM,qBAAqB,CAAC;AAC7B,OAAO,KAAK,EAAsB,YAAY,EAAE,MAAM,oBAAoB,CAAC;AAO3E;;GAEG;AACH,UAAU,kBAAmB,SAAQ,aAAa;IAChD,oBAAoB;IACpB,IAAI,CAAC,EAAE,MAAM,CAAC;IACd,oBAAoB;IACpB,IAAI,CAAC,EAAE,YAAY,CAAC;IACpB,wBAAwB;IACxB,IAAI,CAAC,EAAE,MAAM,CAAC;IACd,sBAAsB;IACtB,cAAc,CAAC,EAAE,MAAM,CAAC;IACxB,sBAAsB;IACtB,cAAc,CAAC,EAAE,OAAO,CAAC;CAC1B;AAED;;GAEG;AACH,wBAAsB,kBAAkB,CAAC,OAAO,GAAE,kBAAuB,GAAG,OAAO,CAAC,IAAI,CAAC,CAmGxF;AAsHD;;GAEG;AACH,UAAU,mBAAmB;IAC3B,qBAAqB;IACrB,IAAI,CAAC,EAAE,OAAO,CAAC;CAChB;AAYD;;GAEG;AACH,wBAAsB,mBAAmB,CACvC,IAAI,EAAE,MAAM,GAAG,SAAS,EACxB,OAAO,GAAE,mBAAwB,GAChC,OAAO,CAAC,IAAI,CAAC,CAoEf"}

package/dist/commands/contract.command.js

@@ -0,0 +1,259 @@
+import { existsSync, readFileSync, writeFileSync } from 'node:fs';
+import { join, resolve, extname } from 'node:path';
+import chalk from 'chalk';
+import { parse as parseYaml, stringify as stringifyYaml } from 'yaml';
+import { VersionManager } from '@contractual/changesets';
+import { loadConfig } from '../config/index.js';
+import { ensureContractualDir, detectSpecType, CONTRACTUAL_DIR, findContractualDir, } from '../utils/files.js';
+import { promptInput, promptSelect, promptVersion, CONTRACT_TYPE_CHOICES, } from '../utils/prompts.js';
+/**
+ * Default version for new contracts
+ */
+const DEFAULT_VERSION = '0.0.0';
+/**
+ * Add a new contract to the configuration
+ */
+export async function contractAddCommand(options = {}) {
+    const cwd = process.cwd();
+    const configPath = join(cwd, 'contractual.yaml');
+    // Check if initialized
+    if (!existsSync(configPath)) {
+        console.log(chalk.red('Not initialized:') + ' contractual.yaml not found');
+        console.log(chalk.dim('Run `contractual init` first'));
+        process.exitCode = 1;
+        return;
+    }
+    // Read existing config
+    const configContent = readFileSync(configPath, 'utf-8');
+    const config = parseYaml(configContent);
+    if (!config.contracts) {
+        config.contracts = [];
+    }
+    // Get contract details through prompts or options
+    const contractName = await getContractName(config.contracts, options);
+    if (!contractName)
+        return;
+    const specPath = await getSpecPath(cwd, options);
+    if (!specPath)
+        return;
+    const contractType = await getContractType(cwd, specPath, options);
+    if (!contractType)
+        return;
+    const version = await getVersion(options);
+    // Validate spec file
+    if (!options.skipValidation) {
+        const absolutePath = resolve(cwd, specPath);
+        const detectedType = detectSpecType(absolutePath);
+        if (!detectedType) {
+            console.log(chalk.red('Invalid spec file:') + ' Could not detect spec type');
+            console.log(chalk.dim(`Expected: ${contractType}`));
+            process.exitCode = 1;
+            return;
+        }
+        if (detectedType !== contractType) {
+            console.log(chalk.yellow('Type mismatch:') +
+                ` Detected ${chalk.cyan(detectedType)}, specified ${chalk.cyan(contractType)}`);
+            console.log(chalk.dim('Use --skip-validation to override'));
+            process.exitCode = 1;
+            return;
+        }
+        console.log(chalk.green('✓') + ` Valid ${contractType} spec`);
+    }
+    // Create contract definition
+    const contract = {
+        name: contractName,
+        type: contractType,
+        path: specPath,
+    };
+    // Add to config
+    config.contracts.push(contract);
+    // Write updated config
+    const yamlContent = stringifyYaml(config, {
+        lineWidth: 100,
+        singleQuote: true,
+    });
+    writeFileSync(configPath, yamlContent, 'utf-8');
+    // Ensure .contractual directory exists and create snapshot
+    const contractualDir = findContractualDir(cwd) ?? join(cwd, CONTRACTUAL_DIR);
+    ensureContractualDir(cwd);
+    const versionManager = new VersionManager(contractualDir);
+    const absolutePath = resolve(cwd, specPath);
+    versionManager.setVersion(contractName, version, absolutePath);
+    // Print summary
+    const snapshotExt = extname(specPath) || '.yaml';
+    console.log();
+    console.log(chalk.green('✓') + ` Added ${chalk.cyan(contractName)} (${contractType}) at v${version}`);
+    console.log();
+    console.log(chalk.bold('Updated:'));
+    console.log(`  ${chalk.yellow('~')} contractual.yaml`);
+    console.log(chalk.bold('Created:'));
+    console.log(`  ${chalk.green('+')} .contractual/snapshots/${contractName}${snapshotExt}`);
+    console.log(`  ${chalk.green('+')} .contractual/versions.json (updated)`);
+}
+/**
+ * Get contract name through prompts or options
+ */
+async function getContractName(existingContracts, options) {
+    const existingNames = new Set(existingContracts.map((c) => c.name));
+    if (options.name) {
+        if (existingNames.has(options.name)) {
+            console.log(chalk.red('Contract exists:') + ` ${options.name} already defined`);
+            process.exitCode = 1;
+            return null;
+        }
+        return options.name;
+    }
+    const name = await promptInput('Contract name:', '', options);
+    if (!name) {
+        console.log(chalk.red('Contract name is required'));
+        process.exitCode = 1;
+        return null;
+    }
+    if (existingNames.has(name)) {
+        console.log(chalk.red('Contract exists:') + ` ${name} already defined`);
+        process.exitCode = 1;
+        return null;
+    }
+    // Validate name format (alphanumeric, hyphens, underscores)
+    if (!/^[a-zA-Z][a-zA-Z0-9_-]*$/.test(name)) {
+        console.log(chalk.red('Invalid name:') +
+            ' Must start with letter, contain only letters, numbers, hyphens, underscores');
+        process.exitCode = 1;
+        return null;
+    }
+    return name;
+}
+/**
+ * Get spec path through prompts or options
+ */
+async function getSpecPath(cwd, options) {
+    if (options.path) {
+        const absolutePath = resolve(cwd, options.path);
+        if (!existsSync(absolutePath)) {
+            console.log(chalk.red('File not found:') + ` ${options.path}`);
+            process.exitCode = 1;
+            return null;
+        }
+        return options.path;
+    }
+    const path = await promptInput('Path to spec file:', '', options);
+    if (!path) {
+        console.log(chalk.red('Spec path is required'));
+        process.exitCode = 1;
+        return null;
+    }
+    const absolutePath = resolve(cwd, path);
+    if (!existsSync(absolutePath)) {
+        console.log(chalk.red('File not found:') + ` ${path}`);
+        process.exitCode = 1;
+        return null;
+    }
+    return path;
+}
+/**
+ * Get contract type through prompts or options
+ */
+async function getContractType(cwd, specPath, options) {
+    if (options.type) {
+        return options.type;
+    }
+    // Try to auto-detect type
+    const absolutePath = resolve(cwd, specPath);
+    const detectedType = detectSpecType(absolutePath);
+    if (detectedType && options.yes) {
+        return detectedType;
+    }
+    const typeChoices = CONTRACT_TYPE_CHOICES.map((c) => ({
+        ...c,
+        name: detectedType === c.value ? `${c.name} (detected)` : c.name,
+    }));
+    return promptSelect('Contract type:', [...typeChoices], detectedType ?? 'openapi', options);
+}
+/**
+ * Get version through prompts or options
+ */
+async function getVersion(options) {
+    if (options.initialVersion) {
+        return options.initialVersion;
+    }
+    return promptVersion('Initial version:', DEFAULT_VERSION, options);
+}
+/**
+ * List contracts
+ */
+export async function contractListCommand(name, options = {}) {
+    let config;
+    try {
+        config = loadConfig();
+    }
+    catch (error) {
+        const message = error instanceof Error ? error.message : 'Unknown error';
+        console.error(chalk.red('Failed to load configuration:'), message);
+        process.exitCode = 1;
+        return;
+    }
+    const contractualDir = findContractualDir(config.configDir);
+    const versionManager = contractualDir ? new VersionManager(contractualDir) : null;
+    // Build contract info list
+    let contracts = config.contracts.map((c) => ({
+        name: c.name,
+        type: c.type,
+        version: versionManager?.getVersion(c.name) ?? '0.0.0',
+        path: c.path,
+    }));
+    // Filter by name if provided
+    if (name) {
+        contracts = contracts.filter((c) => c.name === name);
+        if (contracts.length === 0) {
+            console.error(chalk.red(`Contract not found: ${name}`));
+            process.exitCode = 1;
+            return;
+        }
+    }
+    // Output
+    if (options.json) {
+        console.log(JSON.stringify(contracts, null, 2));
+        return;
+    }
+    // Table output
+    if (contracts.length === 0) {
+        console.log(chalk.dim('No contracts configured.'));
+        return;
+    }
+    // Calculate column widths
+    const maxNameLen = Math.max(4, ...contracts.map((c) => c.name.length));
+    const maxTypeLen = Math.max(4, ...contracts.map((c) => c.type.length));
+    const maxVersionLen = Math.max(7, ...contracts.map((c) => c.version.length));
+    // Header
+    const header = `${'Name'.padEnd(maxNameLen)}  ` +
+        `${'Type'.padEnd(maxTypeLen)}  ` +
+        `${'Version'.padEnd(maxVersionLen)}  ` +
+        `Path`;
+    console.log(chalk.dim(header));
+    console.log(chalk.dim('─'.repeat(header.length + 10)));
+    // Rows
+    for (const contract of contracts) {
+        const typeColor = getTypeColor(contract.type);
+        console.log(`${chalk.cyan(contract.name.padEnd(maxNameLen))}  ` +
+            `${typeColor(contract.type.padEnd(maxTypeLen))}  ` +
+            `${chalk.green(contract.version.padEnd(maxVersionLen))}  ` +
+            `${chalk.dim(contract.path)}`);
+    }
+}
+/**
+ * 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/diff.command.d.ts

@@ -0,0 +1,21 @@
+/**
+ * Diff Command
+ *
+ * Show all changes between current specs and their last versioned snapshots,
+ * classified by severity.
+ *
+ * Unlike `breaking`, which is a CI gate (exits 1 on breaking changes),
+ * `diff` is informational — it always exits 0 on success.
+ */
+interface DiffOptions {
+    contract?: string;
+    format?: 'text' | 'json';
+    severity?: 'all' | 'breaking' | 'non-breaking' | 'patch';
+    verbose?: boolean;
+}
+/**
+ * Show all changes between current specs and last versioned snapshots
+ */
+export declare function diffCommand(options: DiffOptions): Promise<void>;
+export {};
+//# sourceMappingURL=diff.command.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"diff.command.d.ts","sourceRoot":"","sources":["../../src/commands/diff.command.ts"],"names":[],"mappings":"AAAA;;;;;;;;GAQG;AAQH,UAAU,WAAW;IACnB,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,MAAM,CAAC,EAAE,MAAM,GAAG,MAAM,CAAC;IACzB,QAAQ,CAAC,EAAE,KAAK,GAAG,UAAU,GAAG,cAAc,GAAG,OAAO,CAAC;IACzD,OAAO,CAAC,EAAE,OAAO,CAAC;CACnB;AAED;;GAEG;AACH,wBAAsB,WAAW,CAAC,OAAO,EAAE,WAAW,GAAG,OAAO,CAAC,IAAI,CAAC,CA4CrE"}

package/dist/commands/diff.command.js

@@ -0,0 +1,58 @@
+/**
+ * Diff Command
+ *
+ * Show all changes between current specs and their last versioned snapshots,
+ * classified by severity.
+ *
+ * Unlike `breaking`, which is a CI gate (exits 1 on breaking changes),
+ * `diff` is informational — it always exits 0 on success.
+ */
+import chalk from 'chalk';
+import ora from 'ora';
+import { loadConfig } from '../config/index.js';
+import { diffContracts } from '../core/diff.js';
+import { formatDiffText, formatDiffJson, filterBySeverity } from '../formatters/diff.js';
+/**
+ * Show all changes between current specs and last versioned snapshots
+ */
+export async function diffCommand(options) {
+    const spinner = ora('Loading configuration...').start();
+    let config;
+    try {
+        config = loadConfig();
+        spinner.succeed('Configuration loaded');
+    }
+    catch (error) {
+        spinner.fail('Failed to load configuration');
+        const message = error instanceof Error ? error.message : 'Unknown error';
+        console.error(chalk.red(message));
+        process.exitCode = 2;
+        return;
+    }
+    const diffSpinner = ora('Comparing specs against snapshots...').start();
+    try {
+        const { results } = await diffContracts(config, {
+            contracts: options.contract ? [options.contract] : undefined,
+            includeEmpty: true, // Show "no changes" for contracts with no diff
+        });
+        diffSpinner.succeed('Comparison complete');
+        console.log();
+        // Apply severity filter
+        const filtered = filterBySeverity(results, options.severity ?? 'all');
+        // Output results
+        if (options.format === 'json') {
+            console.log(formatDiffJson(filtered));
+        }
+        else {
+            formatDiffText(filtered, { verbose: options.verbose });
+        }
+        // diff always exits 0 on success (it's informational, not a gate)
+        process.exitCode = 0;
+    }
+    catch (error) {
+        diffSpinner.fail('Comparison failed');
+        const message = error instanceof Error ? error.message : 'Unknown error';
+        console.error(chalk.red('Error:'), message);
+        process.exitCode = 3; // Tool execution error
+    }
+}

package/dist/commands/index.d.ts

@@ -0,0 +1,7 @@
+export * from './init.command.js';
+export * from './lint.command.js';
+export * from './breaking.command.js';
+export * from './changeset.command.js';
+export * from './version.command.js';
+export * from './status.command.js';
+//# sourceMappingURL=index.d.ts.map

package/dist/commands/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/commands/index.ts"],"names":[],"mappings":"AAAA,cAAc,mBAAmB,CAAC;AAClC,cAAc,mBAAmB,CAAC;AAClC,cAAc,uBAAuB,CAAC;AACtC,cAAc,wBAAwB,CAAC;AACvC,cAAc,sBAAsB,CAAC;AACrC,cAAc,qBAAqB,CAAC"}

package/dist/commands/index.js

@@ -0,0 +1,6 @@
+export * from './init.command.js';
+export * from './lint.command.js';
+export * from './breaking.command.js';
+export * from './changeset.command.js';
+export * from './version.command.js';
+export * from './status.command.js';