@contractual/cli 0.1.0-dev.0

package/dist/commands/status.command.js

@@ -0,0 +1,120 @@
+import { existsSync, readFileSync } from 'node:fs';
+import { join } from 'node:path';
+import chalk from 'chalk';
+import { loadConfig } from '../config/index.js';
+import { findContractualDir, VERSIONS_FILE, CHANGESETS_DIR } from '../utils/files.js';
+import { aggregateBumps, incrementVersion, readChangesets } from '@contractual/changesets';
+/**
+ * Read versions.json file
+ */
+function readVersions(contractualDir) {
+    const versionsPath = join(contractualDir, VERSIONS_FILE);
+    if (!existsSync(versionsPath)) {
+        return {};
+    }
+    try {
+        const content = readFileSync(versionsPath, 'utf-8');
+        return JSON.parse(content);
+    }
+    catch {
+        return {};
+    }
+}
+/**
+ * Show current state - versions, pending changesets, projected bumps
+ */
+export async function statusCommand() {
+    try {
+        // Load config
+        const config = loadConfig();
+        const contractualDir = findContractualDir();
+        if (!contractualDir) {
+            console.log(chalk.red('Not initialized:') + ' .contractual directory not found');
+            console.log(chalk.dim('Run `contractual init` to get started'));
+            process.exitCode = 1;
+            return;
+        }
+        // Read versions
+        const versions = readVersions(contractualDir);
+        // Read pending changesets
+        const changesetsDir = join(contractualDir, CHANGESETS_DIR);
+        let changesets = [];
+        try {
+            changesets = await readChangesets(changesetsDir);
+        }
+        catch (error) {
+            // If parsing fails, show a warning but continue
+            const message = error instanceof Error ? error.message : 'Unknown error';
+            console.warn(chalk.yellow(`Warning: ${message}`));
+        }
+        // Calculate projected bumps
+        const projectedBumps = aggregateBumps(changesets);
+        // Print header
+        console.log(chalk.bold('\nContractual Status\n'));
+        // Print contract versions
+        console.log(chalk.bold.underline('Contracts'));
+        console.log();
+        if (config.contracts.length === 0) {
+            console.log(chalk.dim('  No contracts configured'));
+        }
+        else {
+            for (const contract of config.contracts) {
+                const versionEntry = versions[contract.name];
+                const currentVersion = versionEntry?.version ?? '0.0.0';
+                const bump = projectedBumps[contract.name];
+                let projectedVersion = null;
+                if (bump) {
+                    projectedVersion = incrementVersion(currentVersion, bump);
+                }
+                // Contract name and type
+                const typeLabel = chalk.dim(`(${contract.type})`);
+                console.log(`  ${chalk.cyan(contract.name)} ${typeLabel}`);
+                // Version info
+                const versionLabel = versionEntry
+                    ? chalk.green(`v${currentVersion}`)
+                    : chalk.dim('v0.0.0 (unreleased)');
+                if (projectedVersion) {
+                    const bumpColor = bump === 'major' ? chalk.red : bump === 'minor' ? chalk.yellow : chalk.green;
+                    console.log(`    ${versionLabel} ${chalk.dim('->')} ${bumpColor(`v${projectedVersion}`)} ${chalk.dim(`(${bump})`)}`);
+                }
+                else {
+                    console.log(`    ${versionLabel}`);
+                }
+                // Release date
+                if (versionEntry?.released) {
+                    const date = new Date(versionEntry.released).toLocaleDateString();
+                    console.log(`    ${chalk.dim(`Released: ${date}`)}`);
+                }
+                console.log();
+            }
+        }
+        // Print pending changesets
+        console.log(chalk.bold.underline('Pending Changesets'));
+        console.log();
+        if (changesets.length === 0) {
+            console.log(chalk.dim('  No pending changesets'));
+            console.log(chalk.dim('  Run `contractual add` to create one'));
+        }
+        else {
+            console.log(`  ${chalk.yellow(changesets.length.toString())} changeset(s) pending\n`);
+            for (const changeset of changesets) {
+                console.log(`  ${chalk.dim('-')} ${changeset.filename}`);
+                for (const [contract, bump] of Object.entries(changeset.bumps)) {
+                    const bumpColor = bump === 'major' ? chalk.red : bump === 'minor' ? chalk.yellow : chalk.green;
+                    console.log(`      ${chalk.cyan(contract)}: ${bumpColor(bump)}`);
+                }
+            }
+        }
+        console.log();
+        // Summary
+        const hasProjectedBumps = Object.keys(projectedBumps).length > 0;
+        if (hasProjectedBumps) {
+            console.log(chalk.dim('Run `contractual version` to apply pending changesets and bump versions'));
+        }
+    }
+    catch (error) {
+        const message = error instanceof Error ? error.message : 'Unknown error';
+        console.error(chalk.red('Error:'), message);
+        process.exitCode = 1;
+    }
+}

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

@@ -0,0 +1,16 @@
+import { type PromptOptions } from '../utils/prompts.js';
+/**
+ * Options for the version command
+ */
+interface VersionOptions extends PromptOptions {
+    /** Preview without applying */
+    dryRun?: boolean;
+    /** Output JSON (implies --yes) */
+    json?: boolean;
+}
+/**
+ * Consume changesets and bump versions
+ */
+export declare function versionCommand(options?: VersionOptions): Promise<void>;
+export {};
+//# sourceMappingURL=version.command.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"version.command.d.ts","sourceRoot":"","sources":["../../src/commands/version.command.ts"],"names":[],"mappings":"AAMA,OAAO,EAAiB,KAAK,aAAa,EAAE,MAAM,qBAAqB,CAAC;AAaxE;;GAEG;AACH,UAAU,cAAe,SAAQ,aAAa;IAC5C,+BAA+B;IAC/B,MAAM,CAAC,EAAE,OAAO,CAAC;IACjB,kCAAkC;IAClC,IAAI,CAAC,EAAE,OAAO,CAAC;CAChB;AAYD;;GAEG;AACH,wBAAsB,cAAc,CAAC,OAAO,GAAE,cAAmB,GAAG,OAAO,CAAC,IAAI,CAAC,CAsOhF"}

package/dist/commands/version.command.js

@@ -0,0 +1,247 @@
+import { existsSync, unlinkSync } from 'node:fs';
+import { join } from 'node:path';
+import chalk from 'chalk';
+import ora from 'ora';
+import { loadConfig } from '../config/index.js';
+import { findContractualDir, CHANGESETS_DIR } from '../utils/files.js';
+import { promptConfirm } from '../utils/prompts.js';
+import { VersionManager, PreReleaseManager, readChangesets, aggregateBumps, extractContractChanges, appendChangelog, incrementVersion, incrementVersionWithPreRelease, } from '@contractual/changesets';
+/**
+ * Consume changesets and bump versions
+ */
+export async function versionCommand(options = {}) {
+    // JSON output implies --yes (no prompts)
+    if (options.json) {
+        options.yes = true;
+    }
+    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);
+    }
+    const contractualDir = findContractualDir(config.configDir);
+    if (!contractualDir) {
+        console.error(chalk.red('No .contractual directory found. Run `contractual init` first.'));
+        process.exit(1);
+    }
+    // Read all changesets
+    const readSpinner = ora('Reading changesets...').start();
+    const changesetsDir = join(contractualDir, CHANGESETS_DIR);
+    const changesets = await readChangesets(changesetsDir);
+    if (changesets.length === 0) {
+        readSpinner.succeed('No pending changesets');
+        if (options.json) {
+            console.log(JSON.stringify({ bumps: [], changesets: 0 }, null, 2));
+        }
+        else {
+            console.log(chalk.gray('Nothing to version.'));
+        }
+        process.exit(0);
+    }
+    readSpinner.succeed(`Found ${changesets.length} changeset(s)`);
+    // Aggregate bumps (highest wins per contract)
+    const aggregatedBumps = aggregateBumps(changesets);
+    if (Object.keys(aggregatedBumps).length === 0) {
+        if (options.json) {
+            console.log(JSON.stringify({ bumps: [], changesets: changesets.length }, null, 2));
+        }
+        else {
+            console.log(chalk.gray('No version bumps required.'));
+        }
+        process.exit(0);
+    }
+    // Initialize version manager for reading current versions
+    const versionManager = new VersionManager(contractualDir);
+    const preManager = new PreReleaseManager(contractualDir);
+    const preReleaseTag = preManager.getTag();
+    // Calculate pending bumps (preview)
+    const pendingBumps = [];
+    for (const [contractName, bumpType] of Object.entries(aggregatedBumps)) {
+        const contract = config.contracts.find((c) => c.name === contractName);
+        if (!contract) {
+            continue;
+        }
+        const currentVersion = versionManager.getVersion(contractName) ?? '0.0.0';
+        const nextVersion = preReleaseTag
+            ? incrementVersionWithPreRelease(currentVersion, bumpType, preReleaseTag)
+            : incrementVersion(currentVersion, bumpType);
+        pendingBumps.push({
+            contract: contractName,
+            currentVersion,
+            nextVersion,
+            bumpType,
+        });
+    }
+    // Show pre-release mode notice
+    if (preReleaseTag && !options.json) {
+        console.log(chalk.cyan(`Pre-release mode: ${preReleaseTag}`));
+    }
+    // Show preview
+    if (options.json) {
+        if (options.dryRun) {
+            console.log(JSON.stringify({
+                dryRun: true,
+                bumps: pendingBumps.map((b) => ({
+                    contract: b.contract,
+                    current: b.currentVersion,
+                    next: b.nextVersion,
+                    type: b.bumpType,
+                })),
+                changesets: changesets.length,
+            }, null, 2));
+            return;
+        }
+    }
+    else {
+        printPreviewTable(pendingBumps);
+        if (options.dryRun) {
+            console.log();
+            console.log(chalk.dim('Dry run - no changes applied'));
+            return;
+        }
+    }
+    // Confirm before applying (unless --yes)
+    if (!options.json) {
+        const shouldApply = await promptConfirm('Apply these version bumps?', true, options);
+        if (!shouldApply) {
+            console.log(chalk.dim('Cancelled'));
+            return;
+        }
+    }
+    // Apply version bumps
+    const bumpSpinner = options.json ? null : ora('Applying version bumps...').start();
+    const bumpResults = [];
+    const consumedChangesetPaths = [];
+    for (const [contractName, bumpType] of Object.entries(aggregatedBumps)) {
+        const contract = config.contracts.find((c) => c.name === contractName);
+        if (!contract) {
+            if (!options.json) {
+                console.warn(chalk.yellow(`Warning: Contract "${contractName}" not found in config, skipping.`));
+            }
+            continue;
+        }
+        const oldVersion = versionManager.getVersion(contractName) ?? '0.0.0';
+        let newVersion;
+        if (preReleaseTag) {
+            // Use pre-release version increment
+            newVersion = incrementVersionWithPreRelease(oldVersion, bumpType, preReleaseTag);
+            versionManager.setVersion(contractName, newVersion, contract.absolutePath);
+        }
+        else {
+            // Normal bump
+            const result = versionManager.bump(contractName, bumpType, contract.absolutePath);
+            newVersion = result.newVersion;
+        }
+        // Extract changes text from changesets for this contract
+        const changes = extractContractChanges(changesets, contractName);
+        bumpResults.push({
+            contract: contractName,
+            oldVersion,
+            newVersion,
+            bumpType,
+            changes,
+        });
+    }
+    bumpSpinner?.succeed('Version bumps applied');
+    // Append to CHANGELOG.md
+    const changelogSpinner = options.json ? null : ora('Updating changelog...').start();
+    const changelogPath = join(config.configDir, 'CHANGELOG.md');
+    try {
+        appendChangelog(changelogPath, bumpResults);
+        changelogSpinner?.succeed('Changelog updated');
+    }
+    catch (error) {
+        const message = error instanceof Error ? error.message : 'Unknown error';
+        changelogSpinner?.warn(`Failed to update changelog: ${message}`);
+    }
+    // Delete consumed changeset files
+    const cleanupSpinner = options.json ? null : ora('Cleaning up changesets...').start();
+    for (const changeset of changesets) {
+        const changesetPath = join(changesetsDir, changeset.filename);
+        try {
+            if (existsSync(changesetPath)) {
+                unlinkSync(changesetPath);
+                consumedChangesetPaths.push(changeset.filename);
+            }
+        }
+        catch {
+            // Ignore cleanup errors
+        }
+    }
+    cleanupSpinner?.succeed(`Removed ${consumedChangesetPaths.length} changeset(s)`);
+    // Print summary
+    if (options.json) {
+        console.log(JSON.stringify({
+            bumps: bumpResults.map((r) => ({
+                contract: r.contract,
+                old: r.oldVersion,
+                new: r.newVersion,
+                type: r.bumpType,
+            })),
+            changesets: consumedChangesetPaths.length,
+        }, null, 2));
+    }
+    else {
+        console.log();
+        console.log(chalk.bold('Version Summary:'));
+        console.log();
+        for (const result of bumpResults) {
+            console.log(`  ${chalk.cyan(result.contract)}: ` +
+                `${chalk.gray(result.oldVersion)} -> ${chalk.green(result.newVersion)} ` +
+                `(${result.bumpType})`);
+        }
+        console.log();
+        console.log(chalk.green('Done!'), `${bumpResults.length} contract(s) versioned.`);
+    }
+}
+/**
+ * Print a preview table of pending version bumps
+ */
+function printPreviewTable(bumps) {
+    console.log();
+    console.log(chalk.bold('Pending version bumps:'));
+    console.log();
+    // Calculate column widths
+    const maxContractLen = Math.max(8, ...bumps.map((b) => b.contract.length));
+    const maxCurrentLen = Math.max(7, ...bumps.map((b) => b.currentVersion.length));
+    const maxNextLen = Math.max(4, ...bumps.map((b) => b.nextVersion.length));
+    // Header
+    const header = `  ${'Contract'.padEnd(maxContractLen)}  ` +
+        `${'Current'.padEnd(maxCurrentLen)}  ` +
+        `${'→'}  ` +
+        `${'Next'.padEnd(maxNextLen)}  ` +
+        `Reason`;
+    console.log(chalk.dim(header));
+    console.log(chalk.dim('  ' + '─'.repeat(header.length - 2)));
+    // Rows
+    for (const bump of bumps) {
+        const reason = getBumpReason(bump.bumpType);
+        console.log(`  ${chalk.cyan(bump.contract.padEnd(maxContractLen))}  ` +
+            `${chalk.gray(bump.currentVersion.padEnd(maxCurrentLen))}  ` +
+            `${chalk.dim('→')}  ` +
+            `${chalk.green(bump.nextVersion.padEnd(maxNextLen))}  ` +
+            `${reason}`);
+    }
+}
+/**
+ * Get human-readable reason for bump type
+ */
+function getBumpReason(bumpType) {
+    switch (bumpType) {
+        case 'major':
+            return chalk.red('major (breaking)');
+        case 'minor':
+            return chalk.yellow('minor (feature)');
+        case 'patch':
+            return chalk.dim('patch (fix)');
+        default:
+            return bumpType;
+    }
+}

package/dist/commands.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=commands.d.ts.map

package/dist/commands.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"commands.d.ts","sourceRoot":"","sources":["../src/commands.ts"],"names":[],"mappings":""}

package/dist/commands.js

@@ -0,0 +1,84 @@
+import { Command } from 'commander';
+import { initCommand } from './commands/init.command.js';
+import { contractAddCommand, contractListCommand } from './commands/contract.command.js';
+import { lintCommand } from './commands/lint.command.js';
+import { diffCommand } from './commands/diff.command.js';
+import { breakingCommand } from './commands/breaking.command.js';
+import { changesetCommand } from './commands/changeset.command.js';
+import { versionCommand } from './commands/version.command.js';
+import { preEnterCommand, preExitCommand, preStatusCommand } from './commands/pre.command.js';
+import { statusCommand } from './commands/status.command.js';
+const program = new Command();
+program.name('contractual').description('Schema contract lifecycle orchestrator').version('0.1.0');
+program
+    .command('init')
+    .description('Initialize Contractual in this repository')
+    .option('-V, --initial-version <version>', 'Initial version for contracts')
+    .option('--versioning <mode>', 'Versioning mode: independent, fixed')
+    .option('-y, --yes', 'Skip prompts and use defaults')
+    .option('--force', 'Reinitialize existing project')
+    .action(initCommand);
+const contractCmd = program.command('contract').description('Manage contracts');
+contractCmd
+    .command('add')
+    .description('Add a new contract to the configuration')
+    .option('-n, --name <name>', 'Contract name')
+    .option('-t, --type <type>', 'Contract type: openapi, asyncapi, json-schema, odcs')
+    .option('-p, --path <path>', 'Path to spec file')
+    .option('--initial-version <version>', 'Initial version (default: 0.0.0)')
+    .option('--skip-validation', 'Skip spec validation')
+    .option('-y, --yes', 'Skip prompts and use defaults')
+    .action(contractAddCommand);
+contractCmd
+    .command('list [name]')
+    .description('List contracts (optionally filter by name)')
+    .option('--json', 'Output as JSON')
+    .action(contractListCommand);
+program
+    .command('lint')
+    .description('Lint all configured contracts')
+    .option('-c, --contract <name>', 'Lint specific contract')
+    .option('--format <format>', 'Output format: text, json', 'text')
+    .option('--fail-on-warn', 'Exit 1 on warnings')
+    .action(lintCommand);
+program
+    .command('diff')
+    .description('Show all changes between current specs and last versioned snapshots')
+    .option('-c, --contract <name>', 'Diff specific contract')
+    .option('--format <format>', 'Output format: text, json', 'text')
+    .option('--severity <level>', 'Filter: all, breaking, non-breaking, patch', 'all')
+    .option('--verbose', 'Show JSON Pointer paths for each change')
+    .action(diffCommand);
+program
+    .command('breaking')
+    .description('Detect breaking changes against last snapshot')
+    .option('-c, --contract <name>', 'Check specific contract')
+    .option('--format <format>', 'Output format: text, json', 'text')
+    .option('--fail-on <level>', 'Exit 1 on: breaking, non-breaking, any', 'breaking')
+    .action(breakingCommand);
+program
+    .command('changeset')
+    .description('Create changeset from detected changes')
+    .action(changesetCommand);
+program
+    .command('version')
+    .description('Consume changesets and bump versions')
+    .option('-y, --yes', 'Skip confirmation prompt')
+    .option('--dry-run', 'Preview without applying')
+    .option('--json', 'Output JSON (implies --yes)')
+    .action(versionCommand);
+const preCmd = program.command('pre').description('Manage pre-release versions');
+preCmd
+    .command('enter <tag>')
+    .description('Enter pre-release mode (e.g., alpha, beta, rc)')
+    .action(preEnterCommand);
+preCmd.command('exit').description('Exit pre-release mode').action(preExitCommand);
+preCmd.command('status').description('Show pre-release status').action(preStatusCommand);
+program
+    .command('status')
+    .description('Show current versions and pending changesets')
+    .action(statusCommand);
+program.parseAsync(process.argv).catch((err) => {
+    console.error(`Error: ${err.message}`);
+    process.exit(2);
+});

package/dist/config/index.d.ts

@@ -0,0 +1,3 @@
+export * from './loader.js';
+export * from './validator.js';
+//# sourceMappingURL=index.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/config/index.ts"],"names":[],"mappings":"AAAA,cAAc,aAAa,CAAC;AAC5B,cAAc,gBAAgB,CAAC"}

package/dist/config/index.js

@@ -0,0 +1,2 @@
+export * from './loader.js';
+export * from './validator.js';

package/dist/config/loader.d.ts

@@ -0,0 +1,28 @@
+import type { ContractualConfig, ResolvedConfig, ResolvedContract } from '@contractual/types';
+/**
+ * Error thrown when config cannot be loaded
+ */
+export declare class ConfigError extends Error {
+    constructor(message: string);
+}
+/**
+ * Find contractual.yaml by walking up from the given directory
+ */
+export declare function findConfigFile(startDir?: string): string | null;
+/**
+ * Parse YAML config file
+ */
+export declare function parseConfigFile(configPath: string): unknown;
+/**
+ * Resolve contract paths to absolute paths
+ */
+export declare function resolveContractPaths(config: ContractualConfig, configDir: string): ResolvedContract[];
+/**
+ * Load and validate config from a file path
+ */
+export declare function loadConfigFromPath(configPath: string): ResolvedConfig;
+/**
+ * Load config by searching from the current directory
+ */
+export declare function loadConfig(startDir?: string): ResolvedConfig;
+//# sourceMappingURL=loader.d.ts.map

package/dist/config/loader.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"loader.d.ts","sourceRoot":"","sources":["../../src/config/loader.ts"],"names":[],"mappings":"AAIA,OAAO,KAAK,EAAE,iBAAiB,EAAE,cAAc,EAAE,gBAAgB,EAAE,MAAM,oBAAoB,CAAC;AAQ9F;;GAEG;AACH,qBAAa,WAAY,SAAQ,KAAK;gBACxB,OAAO,EAAE,MAAM;CAI5B;AAED;;GAEG;AACH,wBAAgB,cAAc,CAAC,QAAQ,GAAE,MAAsB,GAAG,MAAM,GAAG,IAAI,CAyB9E;AAED;;GAEG;AACH,wBAAgB,eAAe,CAAC,UAAU,EAAE,MAAM,GAAG,OAAO,CAS3D;AAED;;GAEG;AACH,wBAAgB,oBAAoB,CAClC,MAAM,EAAE,iBAAiB,EACzB,SAAS,EAAE,MAAM,GAChB,gBAAgB,EAAE,CAoCpB;AAED;;GAEG;AACH,wBAAgB,kBAAkB,CAAC,UAAU,EAAE,MAAM,GAAG,cAAc,CAoBrE;AAED;;GAEG;AACH,wBAAgB,UAAU,CAAC,QAAQ,CAAC,EAAE,MAAM,GAAG,cAAc,CAQ5D"}

package/dist/config/loader.js

@@ -0,0 +1,123 @@
+import { existsSync, readFileSync } from 'node:fs';
+import { dirname, join, resolve } from 'node:path';
+import { parse as parseYaml } from 'yaml';
+import fg from 'fast-glob';
+import { validateConfig, formatValidationErrors } from './validator.js';
+/**
+ * Config file names to search for
+ */
+const CONFIG_FILENAMES = ['contractual.yaml', 'contractual.yml'];
+/**
+ * Error thrown when config cannot be loaded
+ */
+export class ConfigError extends Error {
+    constructor(message) {
+        super(message);
+        this.name = 'ConfigError';
+    }
+}
+/**
+ * Find contractual.yaml by walking up from the given directory
+ */
+export function findConfigFile(startDir = process.cwd()) {
+    let currentDir = resolve(startDir);
+    const root = dirname(currentDir);
+    while (currentDir !== root) {
+        for (const filename of CONFIG_FILENAMES) {
+            const configPath = join(currentDir, filename);
+            if (existsSync(configPath)) {
+                return configPath;
+            }
+        }
+        const parentDir = dirname(currentDir);
+        if (parentDir === currentDir)
+            break;
+        currentDir = parentDir;
+    }
+    // Check root directory too
+    for (const filename of CONFIG_FILENAMES) {
+        const configPath = join(currentDir, filename);
+        if (existsSync(configPath)) {
+            return configPath;
+        }
+    }
+    return null;
+}
+/**
+ * Parse YAML config file
+ */
+export function parseConfigFile(configPath) {
+    const content = readFileSync(configPath, 'utf-8');
+    try {
+        return parseYaml(content);
+    }
+    catch (err) {
+        const message = err instanceof Error ? err.message : 'Unknown parse error';
+        throw new ConfigError(`Failed to parse ${configPath}: ${message}`);
+    }
+}
+/**
+ * Resolve contract paths to absolute paths
+ */
+export function resolveContractPaths(config, configDir) {
+    const resolved = [];
+    for (const contract of config.contracts) {
+        const pattern = contract.path;
+        const absolutePattern = resolve(configDir, pattern);
+        // Check if it's a glob pattern
+        if (pattern.includes('*')) {
+            const matches = fg.sync(absolutePattern, { onlyFiles: true });
+            if (matches.length === 0) {
+                console.warn(`Warning: No files matched pattern "${pattern}" for contract "${contract.name}"`);
+            }
+            // For glob patterns, use the first match as the primary path
+            // In the future, we might support multiple specs per contract
+            if (matches.length > 0) {
+                resolved.push({
+                    ...contract,
+                    absolutePath: matches[0],
+                });
+            }
+        }
+        else {
+            // Direct file path
+            if (!existsSync(absolutePattern)) {
+                console.warn(`Warning: File not found "${pattern}" for contract "${contract.name}"`);
+            }
+            resolved.push({
+                ...contract,
+                absolutePath: absolutePattern,
+            });
+        }
+    }
+    return resolved;
+}
+/**
+ * Load and validate config from a file path
+ */
+export function loadConfigFromPath(configPath) {
+    const parsed = parseConfigFile(configPath);
+    const validation = validateConfig(parsed);
+    if (!validation.valid) {
+        throw new ConfigError(`Invalid configuration in ${configPath}:\n${formatValidationErrors(validation.errors)}`);
+    }
+    const config = parsed;
+    const configDir = dirname(configPath);
+    const resolvedContracts = resolveContractPaths(config, configDir);
+    return {
+        ...config,
+        contracts: resolvedContracts,
+        configDir,
+        configPath,
+    };
+}
+/**
+ * Load config by searching from the current directory
+ */
+export function loadConfig(startDir) {
+    const configPath = findConfigFile(startDir);
+    if (!configPath) {
+        throw new ConfigError('No contractual.yaml found. Run `contractual init` to get started.');
+    }
+    return loadConfigFromPath(configPath);
+}