@libar-dev/architect 1.0.0-pre.3

package/dist/cli/validate-patterns.js

@@ -0,0 +1,707 @@
+#!/usr/bin/env node
+/**
+ * @architect
+ * @architect-cli
+ * @architect-pattern ValidatePatternsCLI
+ * @architect-status completed
+ * @architect-uses PatternScanner, GherkinScanner, DocExtractor, GherkinExtractor, MasterDataset, CodecUtils
+ * @architect-extract-shapes ValidateCLIConfig, ValidationIssue, ValidationSummary
+ *
+ * ## ValidatePatternsCLI - Cross-Source Pattern Validator
+ *
+ * Cross-validates TypeScript patterns vs Gherkin feature files.
+ * Ensures consistency between code annotations and feature specifications.
+ *
+ * ### Exit Codes
+ *
+ * - `0` - No errors
+ * - `1` - Errors found
+ * - `2` - Warnings found (with --strict)
+ *
+ * ### When to Use
+ *
+ * - Pre-commit validation to ensure code and feature files stay in sync
+ * - CI pipeline to catch documentation drift early
+ * - Strict mode (`--strict`) for production readiness checks
+ */
+// ─── Error Convention ───────────────────────────────────────────────────
+// CLI modules use throw/catch + process.exit(). Pipeline modules use Result<T,E>.
+// See src/cli/error-handler.ts for the unified handler.
+// ────────────────────────────────────────────────────────────────────────
+import { printVersionAndExit } from './version.js';
+import { handleCliError } from './error-handler.js';
+import { getPatternName } from '../api/pattern-helpers.js';
+import { scanPatterns } from '../scanner/index.js';
+import { scanGherkinFiles } from '../scanner/gherkin-scanner.js';
+import { loadConfig, applyProjectSourceDefaults, formatConfigError, } from '../config/config-loader.js';
+import { buildMasterDataset } from '../generators/pipeline/index.js';
+import { ScannerConfigSchema, createJsonOutputCodec, ValidationSummaryOutputSchema, } from '../validation-schemas/index.js';
+import { normalizeStatus, isPatternComplete } from '../taxonomy/index.js';
+import { validateDoD, formatDoDSummary, detectAntiPatterns, formatAntiPatternReport, toValidationIssues, DEFAULT_THRESHOLDS, } from '../validation/index.js';
+/**
+ * Codec for serializing validation summary to JSON
+ */
+const ValidationSummaryCodec = createJsonOutputCodec(ValidationSummaryOutputSchema);
+/**
+ * Parse command line arguments
+ */
+export function parseArgs(argv = process.argv.slice(2)) {
+    const config = {
+        input: [],
+        features: [],
+        exclude: [],
+        baseDir: process.cwd(),
+        strict: false,
+        format: 'pretty',
+        help: false,
+        dod: false,
+        phases: [],
+        antiPatterns: false,
+        scenarioBloatThreshold: DEFAULT_THRESHOLDS.scenarioBloatThreshold,
+        megaFeatureLineThreshold: DEFAULT_THRESHOLDS.megaFeatureLineThreshold,
+        magicCommentThreshold: DEFAULT_THRESHOLDS.magicCommentThreshold,
+        version: false,
+        verbose: false,
+    };
+    for (let i = 0; i < argv.length; i++) {
+        const arg = argv[i];
+        if (arg === '--help' || arg === '-h') {
+            config.help = true;
+        }
+        else if (arg === '--input' || arg === '-i') {
+            const nextArg = argv[++i];
+            if (!nextArg) {
+                throw new Error(`Missing value for ${arg} flag`);
+            }
+            config.input.push(nextArg);
+        }
+        else if (arg === '--features' || arg === '-F') {
+            const nextArg = argv[++i];
+            if (!nextArg) {
+                throw new Error(`Missing value for ${arg} flag`);
+            }
+            config.features.push(nextArg);
+        }
+        else if (arg === '--exclude' || arg === '-e') {
+            const nextArg = argv[++i];
+            if (!nextArg) {
+                throw new Error(`Missing value for ${arg} flag`);
+            }
+            config.exclude.push(nextArg);
+        }
+        else if (arg === '--base-dir' || arg === '-b') {
+            const nextArg = argv[++i];
+            if (!nextArg) {
+                throw new Error(`Missing value for ${arg} flag`);
+            }
+            config.baseDir = nextArg;
+        }
+        else if (arg === '--strict') {
+            config.strict = true;
+        }
+        else if (arg === '--format' || arg === '-f') {
+            const nextArg = argv[++i];
+            if (!nextArg) {
+                throw new Error(`Missing value for ${arg} flag`);
+            }
+            if (nextArg !== 'pretty' && nextArg !== 'json') {
+                throw new Error(`Invalid format: ${nextArg}. Use "pretty" or "json"`);
+            }
+            config.format = nextArg;
+        }
+        else if (arg === '--dod') {
+            config.dod = true;
+        }
+        else if (arg === '--phase') {
+            const nextArg = argv[++i];
+            if (!nextArg) {
+                throw new Error(`Missing value for ${arg} flag`);
+            }
+            const phaseNum = parseInt(nextArg, 10);
+            if (isNaN(phaseNum) || phaseNum < 1) {
+                throw new Error(`Invalid phase number: ${nextArg}. Must be a positive integer.`);
+            }
+            config.phases.push(phaseNum);
+        }
+        else if (arg === '--anti-patterns') {
+            config.antiPatterns = true;
+        }
+        else if (arg === '--scenario-threshold') {
+            const nextArg = argv[++i];
+            if (!nextArg) {
+                throw new Error(`Missing value for ${arg} flag`);
+            }
+            const threshold = parseInt(nextArg, 10);
+            if (isNaN(threshold) || threshold < 1) {
+                throw new Error(`Invalid threshold: ${nextArg}. Must be a positive integer.`);
+            }
+            config.scenarioBloatThreshold = threshold;
+        }
+        else if (arg === '--mega-feature-threshold') {
+            const nextArg = argv[++i];
+            if (!nextArg) {
+                throw new Error(`Missing value for ${arg} flag`);
+            }
+            const threshold = parseInt(nextArg, 10);
+            if (isNaN(threshold) || threshold < 1) {
+                throw new Error(`Invalid threshold: ${nextArg}. Must be a positive integer.`);
+            }
+            config.megaFeatureLineThreshold = threshold;
+        }
+        else if (arg === '--magic-comment-threshold') {
+            const nextArg = argv[++i];
+            if (!nextArg) {
+                throw new Error(`Missing value for ${arg} flag`);
+            }
+            const threshold = parseInt(nextArg, 10);
+            if (isNaN(threshold) || threshold < 1) {
+                throw new Error(`Invalid threshold: ${nextArg}. Must be a positive integer.`);
+            }
+            config.magicCommentThreshold = threshold;
+        }
+        else if (arg === '--version' || arg === '-v') {
+            config.version = true;
+        }
+        else if (arg === '--verbose') {
+            config.verbose = true;
+        }
+        else if (arg?.startsWith('-') === true) {
+            console.warn(`Warning: Unknown flag '${arg}' ignored`);
+        }
+    }
+    return config;
+}
+/**
+ * Print usage information
+ */
+export function printHelp() {
+    console.log(`
+architect-validate - Cross-validate TypeScript patterns vs Gherkin features
+
+Usage:
+  architect-validate [options]
+
+Options:
+  -i, --input <pattern>       Glob pattern for TypeScript files (repeatable; falls back to config)
+  -F, --features <pattern>    Glob pattern for Gherkin feature files (repeatable; falls back to config)
+  -e, --exclude <pattern>     Glob pattern to exclude (repeatable)
+  -b, --base-dir <dir>        Base directory for paths (default: cwd)
+  --strict                    Treat warnings as errors (exit 2 on warnings)
+  --verbose                   Show info-level messages (hidden by default)
+  -f, --format <type>         Output format: "pretty" (default) or "json"
+  -h, --help                  Show this help message
+  -v, --version               Show version number
+
+DoD Validation:
+  --dod                       Enable Definition of Done validation
+  --phase <N>                 Validate specific phase (repeatable, default: all completed)
+
+Anti-Pattern Detection:
+  --anti-patterns             Enable anti-pattern detection
+  --scenario-threshold <N>    Max scenarios per feature (default: 30)
+  --mega-feature-threshold <N> Max lines per feature (default: 750)
+  --magic-comment-threshold <N> Max magic comments (default: 5)
+
+Exit Codes:
+  0  No issues found
+  1  Errors found
+  2  Warnings found (with --strict)
+
+Cross-Source Validation Checks:
+  error    phase-mismatch               Phase number differs between sources
+  error    status-mismatch              Status differs between sources
+  warning  missing-pattern-in-gherkin   Pattern in TypeScript has no matching feature
+  warning  missing-deliverables         Completed phase has no deliverables defined
+  warning  deliverable-missing-fields   Deliverable missing required fields
+  info     missing-pattern-in-ts        Pattern in Gherkin has no matching TypeScript
+  info     unmatched-dependency         Dependency references non-existent pattern
+
+DoD Validation Checks (--dod):
+  error    incomplete-deliverables      Completed phase has incomplete deliverables
+  error    missing-acceptance-criteria  Completed phase has no @acceptance-criteria scenarios
+
+Anti-Pattern Detection (--anti-patterns):
+  error    tag-duplication              Dependencies in features (should be code-only)
+  error    process-in-code              Process metadata in code (should be features-only)
+  warning  magic-comments               Too many generator hints in features
+  warning  scenario-bloat               Too many scenarios per feature
+  warning  mega-feature                 Feature file too large
+
+Examples:
+  # Cross-source validation
+  architect-validate -i "src/**/*.ts" -F "tests/features/**/*.feature"
+
+  # DoD validation for all completed phases
+  architect-validate -i "src/**/*.ts" -F "features/**/*.feature" --dod
+
+  # DoD validation for specific phase
+  architect-validate -i "src/**/*.ts" -F "features/**/*.feature" --dod --phase 14
+
+  # Anti-pattern detection
+  architect-validate -i "src/**/*.ts" -F "features/**/*.feature" --anti-patterns
+
+  # Full validation (cross-source + DoD + anti-patterns)
+  architect-validate -i "src/**/*.ts" -F "features/**/*.feature" --dod --anti-patterns --strict
+
+  # JSON output for tooling
+  architect-validate -i "src/**/*.ts" -F "features/**/*.feature" --format json
+  `);
+}
+/**
+ * Check if a TS pattern has a cross-source match via implements relationships.
+ *
+ * DD-3 Phase 2: For TS patterns not matched by name, check:
+ * 1. If any Gherkin pattern implements this TS pattern (implementedBy)
+ * 2. If this TS pattern implements a Gherkin pattern (implementsPatterns)
+ */
+function hasImplementsMatch(tsPattern, tsName, gherkinByName, dataset) {
+    // Check if a Gherkin pattern implements this TS pattern
+    if ((dataset.relationshipIndex?.[tsName]?.implementedBy.length ?? 0) > 0) {
+        return true;
+    }
+    // Check if this TS pattern implements a Gherkin pattern
+    const implements_ = tsPattern.implementsPatterns ?? [];
+    for (const implName of implements_) {
+        if (gherkinByName.has(implName.toLowerCase())) {
+            return true;
+        }
+    }
+    return false;
+}
+/**
+ * Check if a Gherkin pattern has a cross-source match via implements relationships.
+ *
+ * Symmetric counterpart to hasImplementsMatch for the Gherkin→TS direction:
+ * 1. If a TS pattern implements this Gherkin pattern (implementedBy)
+ * 2. If this Gherkin pattern implements a TS pattern (implementsPatterns)
+ */
+function hasGherkinImplementsMatch(gherkinPattern, tsByName, dataset) {
+    const name = getPatternName(gherkinPattern);
+    // Check reverse: a TS pattern implements this Gherkin pattern
+    if (dataset.relationshipIndex?.[name]?.implementedBy.some((ref) => tsByName.has(ref.name.toLowerCase())) === true) {
+        return true;
+    }
+    // Check forward: this Gherkin pattern implements a TS pattern
+    const implements_ = gherkinPattern.implementsPatterns ?? [];
+    for (const implName of implements_) {
+        if (tsByName.has(implName.toLowerCase())) {
+            return true;
+        }
+    }
+    return false;
+}
+/**
+ * Validate cross-source consistency using the MasterDataset read model.
+ *
+ * Compares TypeScript patterns against Gherkin patterns to find:
+ * - Missing patterns in either source (with implements-aware resolution)
+ * - Phase number mismatches
+ * - Status mismatches (after normalization)
+ * - Missing deliverables for completed phases
+ * - Invalid dependencies
+ *
+ * DD-2: Consumes RuntimeMasterDataset instead of raw scanner/extractor output.
+ * DD-3: Two-phase matching — name-based first, then relationshipIndex fallback.
+ *
+ * @param dataset - The pre-computed MasterDataset read model
+ * @returns Validation summary with issues and statistics
+ */
+export function validatePatterns(dataset) {
+    const issues = [];
+    const tsPatterns = dataset.bySource.typescript;
+    const gherkinPatterns = dataset.bySource.gherkin;
+    // Phase 1: Build name-based maps for efficient lookups
+    const tsByName = new Map();
+    const gherkinByName = new Map();
+    for (const p of tsPatterns) {
+        tsByName.set(getPatternName(p).toLowerCase(), p);
+    }
+    for (const p of gherkinPatterns) {
+        gherkinByName.set(getPatternName(p).toLowerCase(), p);
+    }
+    let matched = 0;
+    let missingInGherkinCount = 0;
+    // Check TypeScript patterns against Gherkin
+    for (const tsPattern of tsPatterns) {
+        const tsName = getPatternName(tsPattern).toLowerCase();
+        let gherkinMatch = gherkinByName.get(tsName);
+        // If the Gherkin pattern explicitly implements a DIFFERENT pattern, it's not
+        // a true name match — it's a naming collision. The Gherkin pattern belongs to
+        // whichever pattern it declares in @architect-implements.
+        if (gherkinMatch !== undefined) {
+            const gherkinImpl = gherkinMatch.implementsPatterns ?? [];
+            if (gherkinImpl.length > 0 && !gherkinImpl.some((n) => n.toLowerCase() === tsName)) {
+                gherkinMatch = undefined;
+            }
+        }
+        if (!gherkinMatch) {
+            // Phase 2: Check implements relationships before reporting
+            if (hasImplementsMatch(tsPattern, getPatternName(tsPattern), gherkinByName, dataset)) {
+                matched++;
+            }
+            else if (tsPattern.phase !== undefined) {
+                // Only report for roadmap patterns (those with phase numbers)
+                const name = getPatternName(tsPattern);
+                missingInGherkinCount++;
+                issues.push({
+                    severity: 'warning',
+                    message: `Pattern "${name}" in TypeScript has no matching Gherkin feature`,
+                    source: 'cross-source',
+                    pattern: name,
+                    file: tsPattern.source.file,
+                });
+            }
+        }
+        else {
+            matched++;
+            // Check phase consistency
+            if (tsPattern.phase !== undefined && gherkinMatch.phase !== undefined) {
+                if (tsPattern.phase !== gherkinMatch.phase) {
+                    const name = getPatternName(tsPattern);
+                    issues.push({
+                        severity: 'error',
+                        message: `Phase mismatch for "${name}": TypeScript=${tsPattern.phase}, Gherkin=${gherkinMatch.phase}`,
+                        source: 'cross-source',
+                        pattern: name,
+                    });
+                }
+            }
+            // Check status consistency
+            if (tsPattern.status && gherkinMatch.status) {
+                const tsStatus = normalizeStatus(tsPattern.status);
+                const gherkinStatus = normalizeStatus(gherkinMatch.status);
+                if (tsStatus !== gherkinStatus) {
+                    const name = getPatternName(tsPattern);
+                    // Include both raw and normalized values for clarity when they differ textually
+                    const rawDiffers = tsPattern.status.toLowerCase() !== gherkinMatch.status.toLowerCase();
+                    const message = rawDiffers
+                        ? `Status mismatch for "${name}": TypeScript="${tsPattern.status}" (→${tsStatus}), Gherkin="${gherkinMatch.status}" (→${gherkinStatus})`
+                        : `Status mismatch for "${name}": TypeScript=${tsStatus}, Gherkin=${gherkinStatus}`;
+                    issues.push({
+                        severity: 'error',
+                        message,
+                        source: 'cross-source',
+                        pattern: name,
+                    });
+                }
+            }
+        }
+    }
+    // Check Gherkin patterns against TypeScript
+    let missingInTsCount = 0;
+    for (const gherkinPattern of gherkinPatterns) {
+        const gherkinName = getPatternName(gherkinPattern).toLowerCase();
+        let tsMatch = tsByName.get(gherkinName);
+        // Symmetric collision guard: if the TS pattern implements a DIFFERENT Gherkin
+        // pattern, it's a naming collision, not a true match.
+        if (tsMatch !== undefined) {
+            const tsImpl = tsMatch.implementsPatterns ?? [];
+            if (tsImpl.length > 0 && !tsImpl.some((n) => n.toLowerCase() === gherkinName)) {
+                tsMatch = undefined;
+            }
+        }
+        if (!tsMatch) {
+            // Two-phase implements resolution (symmetric with TS→Gherkin direction)
+            if (!hasGherkinImplementsMatch(gherkinPattern, tsByName, dataset)) {
+                const name = getPatternName(gherkinPattern);
+                missingInTsCount++;
+                issues.push({
+                    severity: 'info',
+                    message: `Pattern "${name}" in Gherkin has no matching TypeScript pattern`,
+                    source: 'cross-source',
+                    pattern: name,
+                    file: gherkinPattern.source.file,
+                });
+            }
+        }
+    }
+    // Check deliverables for completed roadmap patterns (those with phase numbers).
+    // Test features and ADRs are completed but don't participate in the deliverables workflow.
+    for (const gherkinPattern of gherkinPatterns) {
+        if (isPatternComplete(gherkinPattern.status) && gherkinPattern.phase !== undefined) {
+            const deliverables = gherkinPattern.deliverables ?? [];
+            const name = getPatternName(gherkinPattern);
+            if (deliverables.length === 0) {
+                issues.push({
+                    severity: 'warning',
+                    message: `Completed pattern "${name}" has no deliverables defined`,
+                    source: 'gherkin',
+                    pattern: name,
+                    file: gherkinPattern.source.file,
+                });
+            }
+            else {
+                // Validate deliverable fields
+                for (const d of deliverables) {
+                    if (!d.name || d.name.trim() === '') {
+                        issues.push({
+                            severity: 'warning',
+                            message: `Deliverable in "${name}" missing name`,
+                            source: 'gherkin',
+                            pattern: name,
+                        });
+                    }
+                }
+            }
+        }
+    }
+    // Check dependencies exist
+    const allPatternNames = new Set([...tsByName.keys(), ...gherkinByName.keys()]);
+    for (const pattern of tsPatterns) {
+        const deps = pattern.dependsOn ?? [];
+        for (const dep of deps) {
+            if (!allPatternNames.has(dep.toLowerCase())) {
+                const name = getPatternName(pattern);
+                issues.push({
+                    severity: 'info',
+                    message: `Pattern "${name}" depends on "${dep}" which does not exist`,
+                    source: 'typescript',
+                    pattern: name,
+                });
+            }
+        }
+    }
+    return {
+        issues,
+        stats: {
+            typescriptPatterns: tsPatterns.length,
+            gherkinPatterns: gherkinPatterns.length,
+            matched,
+            missingInGherkin: missingInGherkinCount,
+            missingInTypeScript: missingInTsCount,
+        },
+    };
+}
+/**
+ * Format summary for pretty output
+ */
+function formatPretty(summary, verbose = false) {
+    const lines = [];
+    lines.push('Pattern Validation Summary');
+    lines.push('==========================');
+    lines.push('');
+    // Stats
+    lines.push(`TypeScript patterns: ${summary.stats.typescriptPatterns}`);
+    lines.push(`Gherkin patterns:    ${summary.stats.gherkinPatterns}`);
+    lines.push(`Matched:             ${summary.stats.matched}`);
+    lines.push('');
+    // Group issues by severity
+    const errors = summary.issues.filter((i) => i.severity === 'error');
+    const warnings = summary.issues.filter((i) => i.severity === 'warning');
+    const infos = summary.issues.filter((i) => i.severity === 'info');
+    if (errors.length > 0) {
+        lines.push(`Errors (${errors.length}):`);
+        for (const issue of errors) {
+            lines.push(`  [ERROR] ${issue.message}`);
+            if (issue.file) {
+                lines.push(`          at ${issue.file}`);
+            }
+        }
+        lines.push('');
+    }
+    if (warnings.length > 0) {
+        lines.push(`Warnings (${warnings.length}):`);
+        for (const issue of warnings) {
+            lines.push(`  [WARN]  ${issue.message}`);
+            if (issue.file) {
+                lines.push(`          at ${issue.file}`);
+            }
+        }
+        lines.push('');
+    }
+    if (infos.length > 0 && verbose) {
+        lines.push(`Info (${infos.length}):`);
+        for (const issue of infos) {
+            lines.push(`  [INFO]  ${issue.message}`);
+            if (issue.file) {
+                lines.push(`          at ${issue.file}`);
+            }
+        }
+        lines.push('');
+    }
+    // Summary line
+    if (errors.length === 0 && warnings.length === 0) {
+        lines.push('All validations passed.');
+    }
+    else {
+        lines.push(`Found ${errors.length} error(s), ${warnings.length} warning(s), ${infos.length} info message(s).`);
+    }
+    return lines.join('\n');
+}
+/**
+ * Format summary as JSON
+ *
+ * Uses ValidationSummaryCodec for type-safe serialization.
+ *
+ * @throws Error if serialization fails (should never happen with valid data)
+ */
+function formatJson(summary) {
+    const result = ValidationSummaryCodec.serialize(summary);
+    if (!result.ok) {
+        throw new Error(`Validation summary serialization failed: ${result.error.message}`);
+    }
+    return result.value;
+}
+/**
+ * Main CLI function
+ */
+async function main() {
+    const config = parseArgs();
+    if (config.version) {
+        printVersionAndExit('architect-validate');
+    }
+    if (config.help) {
+        printHelp();
+        process.exit(0);
+    }
+    // Apply config-based defaults if CLI flags not provided
+    const configApplied = await applyProjectSourceDefaults(config);
+    if (!configApplied && config.input.length === 0) {
+        console.error('  (No architect.config.ts or architect.config.js found; provide -i/--input flags)');
+    }
+    // Validate that we have sources (from CLI or config)
+    if (config.input.length === 0) {
+        console.error('Error: No TypeScript sources specified.');
+        console.error('Provide -i/--input flags or configure sources in architect.config.ts or architect.config.js');
+        process.exit(1);
+    }
+    if (config.features.length === 0) {
+        console.error('Error: No feature files specified.');
+        console.error('Provide -F/--features flags or configure sources in architect.config.ts or architect.config.js');
+        process.exit(1);
+    }
+    try {
+        // Load configuration (discovers architect.config.ts or architect.config.js)
+        const configResult = await loadConfig(config.baseDir);
+        if (!configResult.ok) {
+            console.error(formatConfigError(configResult.error));
+            process.exit(1);
+        }
+        const { instance: dpInstance, isDefault, path: configPath } = configResult.value;
+        const registry = dpInstance.registry;
+        const configSource = !isDefault && configPath ? configPath : '(default libar-generic preset)';
+        if (config.format === 'pretty') {
+            console.log('Validating patterns...');
+            console.log(`  Config: ${configSource}`);
+            console.log(`  Base directory: ${config.baseDir}`);
+            console.log(`  TypeScript patterns: ${config.input.join(', ')}`);
+            console.log(`  Gherkin patterns: ${config.features.join(', ')}`);
+            console.log('');
+        }
+        // Build MasterDataset via shared pipeline factory (DD-7)
+        const pipelineResult = await buildMasterDataset({
+            input: config.input,
+            features: config.features,
+            baseDir: config.baseDir,
+            mergeConflictStrategy: 'concatenate',
+            ...(config.exclude.length > 0 ? { exclude: config.exclude } : {}),
+        });
+        if (!pipelineResult.ok) {
+            throw new Error(`Pipeline error [${pipelineResult.error.step}]: ${pipelineResult.error.message}`);
+        }
+        const { dataset, warnings: pipelineWarnings } = pipelineResult.value;
+        if (config.format === 'pretty') {
+            for (const w of pipelineWarnings) {
+                console.warn(`⚠️  ${w.message}`);
+            }
+        }
+        // Raw scans for stage-1 consumers (DoD validation, anti-pattern detection)
+        // These correctly use scanned file data, not the MasterDataset — see DD-7
+        const scannerConfig = ScannerConfigSchema.parse({
+            patterns: config.input,
+            exclude: config.exclude.length > 0 ? config.exclude : undefined,
+            baseDir: config.baseDir,
+        });
+        const scanResult = await scanPatterns(scannerConfig, registry);
+        if (!scanResult.ok) {
+            throw new Error('Unexpected scan failure');
+        }
+        const gherkinScanResult = await scanGherkinFiles({
+            patterns: config.features,
+            baseDir: config.baseDir,
+        });
+        if (!gherkinScanResult.ok) {
+            throw new Error('Unexpected Gherkin scan failure');
+        }
+        // Warn if no patterns found (common misconfiguration)
+        if (dataset.bySource.typescript.length === 0) {
+            console.warn('⚠️  Warning: No TypeScript patterns found. Check your --input patterns.');
+        }
+        if (dataset.bySource.gherkin.length === 0) {
+            console.warn('⚠️  Warning: No Gherkin patterns found. Check your --features patterns.');
+        }
+        // Run cross-source validation against the read model (DD-2)
+        const summary = validatePatterns(dataset);
+        // Output cross-source results
+        if (config.format === 'pretty') {
+            console.log(formatPretty(summary, config.verbose));
+        }
+        // Run DoD validation if enabled
+        let dodHasErrors = false;
+        if (config.dod) {
+            const dodSummary = validateDoD(gherkinScanResult.value.files, config.phases);
+            if (config.format === 'pretty') {
+                console.log(formatDoDSummary(dodSummary));
+            }
+            // Add DoD failures to issues
+            for (const result of dodSummary.results) {
+                if (!result.isDoDMet) {
+                    dodHasErrors = true;
+                    for (const msg of result.messages) {
+                        if (!msg.startsWith('DoD met')) {
+                            summary.issues.push({
+                                severity: 'error',
+                                message: `[DoD] Phase ${result.phase} (${result.patternName}): ${msg}`,
+                                source: 'gherkin',
+                                pattern: result.patternName,
+                            });
+                        }
+                    }
+                }
+            }
+        }
+        // Run anti-pattern detection if enabled
+        let antiPatternHasErrors = false;
+        if (config.antiPatterns) {
+            const thresholds = {
+                scenarioBloatThreshold: config.scenarioBloatThreshold,
+                megaFeatureLineThreshold: config.megaFeatureLineThreshold,
+                magicCommentThreshold: config.magicCommentThreshold,
+            };
+            const violations = detectAntiPatterns(scanResult.value.files, gherkinScanResult.value.files, {
+                thresholds,
+            });
+            if (config.format === 'pretty') {
+                console.log(formatAntiPatternReport(violations));
+            }
+            // Add anti-pattern violations to issues
+            const antiPatternIssues = toValidationIssues(violations);
+            summary.issues.push(...antiPatternIssues);
+            antiPatternHasErrors = violations.some((v) => v.severity === 'error');
+        }
+        // Output JSON if requested (all results combined)
+        if (config.format === 'json') {
+            console.log(formatJson(summary));
+        }
+        // Determine exit code based on all validation results
+        const hasErrors = summary.issues.some((i) => i.severity === 'error') || dodHasErrors || antiPatternHasErrors;
+        const hasWarnings = summary.issues.some((i) => i.severity === 'warning');
+        if (hasErrors) {
+            process.exit(1);
+        }
+        else if (hasWarnings && config.strict) {
+            process.exit(2);
+        }
+        else {
+            process.exit(0);
+        }
+    }
+    catch (error) {
+        handleCliError(error, 1);
+    }
+}
+// Entry point — catch ensures parseArgs errors reach the unified handler
+void main().catch((error) => {
+    handleCliError(error, 1);
+});
+//# sourceMappingURL=validate-patterns.js.map