@eddacraft/anvil-runtime 0.1.0

package/dist/gate/checks/architecture.check.js

@@ -0,0 +1,394 @@
+/**
+ * Architecture Check - Validate architectural constraints using dependency-cruiser
+ *
+ * Detects:
+ * - Circular dependencies
+ * - Layer/boundary violations
+ * - Orphaned modules (optional)
+ */
+import { BaseCheck } from '../check.interface.js';
+import { getFilesFromContext } from '../../types/gate.types.js';
+import { existsSync } from 'node:fs';
+import { join } from 'node:path';
+import { minimatch } from 'minimatch';
+import { createDebugger } from '@eddacraft/anvil-core';
+import { loadBaseline } from '@eddacraft/anvil-core/architecture';
+const log = createDebugger('check');
+import { createContextBuilder, } from '@eddacraft/anvil-core/architecture';
+import { createWarningResult, createWarningFingerprint, } from '@eddacraft/anvil-core/antipattern';
+import { DependencyAnalyzer } from './architecture/dependency-analyzer.js';
+import { CircularDetector } from './architecture/circular-detector.js';
+import { LayerValidator } from './architecture/layer-validator.js';
+const ARCH_VIOLATION_IDS = {
+    circular: 'ARCH-001',
+    orphan: 'ARCH-002',
+    layer: 'ARCH-003',
+    other: 'ARCH-004',
+};
+const ARCH_VIOLATION_TITLES = {
+    'ARCH-001': 'Circular dependency detected',
+    'ARCH-002': 'Orphaned module',
+    'ARCH-003': 'Layer/boundary violation',
+    'ARCH-004': 'Architecture violation',
+};
+const ARCH_VIOLATION_EXPLANATIONS = {
+    'ARCH-001': 'Circular dependencies make code harder to understand and can cause issues with module loading.',
+    'ARCH-002': 'This module has no dependents or dependencies, which may indicate dead code or missing integration.',
+    'ARCH-003': 'This import crosses an architectural boundary that should not be crossed.',
+    'ARCH-004': 'This import violates a configured architecture rule.',
+};
+const ARCH_VIOLATION_SUGGESTIONS = {
+    'ARCH-001': 'Break the cycle by extracting shared code into a separate module or using dependency injection.',
+    'ARCH-002': 'Either connect this module to your application or remove it if unused.',
+    'ARCH-003': 'Move the import target to an appropriate layer or adjust the boundary definition.',
+    'ARCH-004': 'Review the dependency-cruiser rule and adjust your code or configuration.',
+};
+/**
+ * Score penalties per severity
+ */
+const SEVERITY_PENALTIES = {
+    error: 15,
+    warn: 5,
+    info: 1,
+    ignore: 0,
+};
+/**
+ * Architecture check that validates project structure using dependency-cruiser
+ */
+export class ArchitectureCheck extends BaseCheck {
+    name = 'architecture';
+    description = 'Validate architectural constraints using dependency-cruiser';
+    analyzer = new DependencyAnalyzer();
+    detector = new CircularDetector();
+    validator = new LayerValidator();
+    async run(context) {
+        log(`architecture check starting, workspace=${context.workspace_root}, fullScan=${context.fullScan}`);
+        const config = this.validator.parseConfig(context.check_config);
+        log(`architecture config: scope=${config.scope}, severity_threshold=${config.severity_threshold}, fail_on_circular=${config.fail_on_circular}`);
+        try {
+            // Step 1: Load dependency-cruiser
+            const loadResult = await this.analyzer.loadCruiser();
+            if (!loadResult.success) {
+                log('architecture check: dependency-cruiser not installed, skipping');
+                return this.createSuccess('dependency-cruiser not installed. Run `npm install -D dependency-cruiser` to enable architecture checks.', 100, {
+                    skipped: true,
+                    reason: 'dependency-cruiser not available',
+                    warnings: createWarningResult([], []),
+                });
+            }
+            // Step 2: Load dependency-cruiser config or use defaults
+            const configPath = join(context.workspace_root, config.config_file);
+            let cruiseOptions = await this.analyzer.loadConfig(context.workspace_root, config.config_file);
+            if (!cruiseOptions) {
+                if (existsSync(configPath)) {
+                    log(`architecture check: config file exists but failed to load: ${config.config_file}`);
+                    return this.createFailure(`Failed to load dependency-cruiser config: ${config.config_file}`, 'Config file exists but could not be loaded');
+                }
+                log('architecture check: no config file found, using built-in defaults');
+                // Use default rules for circular dependency and orphan detection
+                cruiseOptions = this.analyzer.getDefaultCruiseOptions();
+            }
+            // Step 3: Determine files to analyse
+            const effectiveConfig = context.fullScan ? { ...config, scope: 'full' } : config;
+            const filesToCruise = this.getFilesToCruise(context, effectiveConfig);
+            if (filesToCruise.length === 0) {
+                log('architecture check: no files to analyse');
+                return this.createSuccess('No files to analyse for architecture violations', 100, {
+                    warnings: createWarningResult([], []),
+                });
+            }
+            log(`architecture check: analysing ${filesToCruise.length} files/patterns`);
+            // Step 4: Run dependency analysis
+            const analysisResult = await this.analyzer.analyze(filesToCruise, cruiseOptions);
+            if (!analysisResult.success || !analysisResult.result) {
+                if (analysisResult.skipped) {
+                    log(`architecture check: analysis skipped, reason=${analysisResult.reason}`);
+                    return this.createSuccess(analysisResult.reason || 'Analysis skipped', 100, {
+                        skipped: true,
+                        reason: analysisResult.reason,
+                        warnings: createWarningResult([], []),
+                    });
+                }
+                log(`architecture check: analysis failed, error=${analysisResult.error}`);
+                return this.createFailure('Dependency analysis failed', analysisResult.error || 'Unknown error');
+            }
+            const output = analysisResult.result;
+            // Step 5: Load baseline if exists (for new-only mode)
+            const baseline = loadBaseline(context.workspace_root);
+            log(`architecture check: baseline loaded=${baseline !== null}, totalCruised=${output.summary.totalCruised}, violations=${output.summary.violations.length}`);
+            // Step 6: Convert ALL violations to Warning format with drift info
+            const allViolations = output.summary.violations;
+            const allWarnings = allViolations.map((v) => this.convertViolationToWarning(v, baseline));
+            // Step 7: In new-only mode (when baseline exists), filter to NEW violations only
+            const warnings = baseline ? allWarnings.filter((w) => w.drift?.isNew !== false) : allWarnings;
+            // Step 8: Calculate score/passed from the effective warnings
+            const effectiveViolations = this.detector.filterNewViolations(allViolations, baseline);
+            const { score, passed, violationsByType } = this.validator.calculateScore(effectiveViolations, config);
+            const warningResult = this.createArchWarningResult(warnings, violationsByType);
+            const message = this.validator.buildMessage(effectiveViolations, output.summary.totalCruised, passed);
+            const architectureContext = this.buildArchitectureContext(allViolations, effectiveViolations, output.summary, violationsByType, baseline, config);
+            log('architecture check result', {
+                passed,
+                score,
+                totalViolations: allViolations.length,
+                newViolations: effectiveViolations.length,
+                violationsByType,
+            });
+            return this.createResult(passed, message, score, {
+                warnings: warningResult,
+                totalModulesCruised: output.summary.totalCruised,
+                violationCount: allViolations.length,
+                newViolationCount: effectiveViolations.length,
+                errorCount: output.summary.error,
+                warnCount: output.summary.warn,
+                infoCount: output.summary.info,
+                violations: allViolations.map((v) => ({
+                    from: v.from,
+                    to: v.to,
+                    rule: v.rule.name,
+                    severity: v.rule.severity,
+                    cycle: v.cycle,
+                })),
+                violationsByType,
+                configFile: existsSync(configPath) ? config.config_file : 'built-in defaults',
+                scope: config.scope,
+                baselineLoaded: baseline !== null,
+                architectureContext,
+            });
+        }
+        catch (error) {
+            log(`architecture check error: ${error instanceof Error ? error.message : 'Unknown error'}`);
+            return this.createFailure('Architecture check failed unexpectedly', error instanceof Error ? error.message : 'Unknown error');
+        }
+    }
+    convertViolationToWarning(violation, baseline) {
+        const violationType = this.detector.categoriseViolation(violation);
+        const id = ARCH_VIOLATION_IDS[violationType];
+        const severity = this.mapCruiserSeverity(violation.rule.severity);
+        const warning = {
+            id,
+            category: 'architecture',
+            severity,
+            confidence: 'high',
+            title: ARCH_VIOLATION_TITLES[id],
+            message: `${violation.from} → ${violation.to} (${violation.rule.name})`,
+            explanation: ARCH_VIOLATION_EXPLANATIONS[id],
+            suggestion: ARCH_VIOLATION_SUGGESTIONS[id],
+            location: {
+                file: violation.from,
+                line: 1,
+            },
+            pattern: violation.rule.name,
+        };
+        warning.fingerprint = createWarningFingerprint(warning);
+        if (baseline) {
+            const isNew = this.detector.isNewViolation(violation, baseline);
+            warning.drift = {
+                isNew,
+                existingCount: baseline.baseline_snapshot.violations.length,
+            };
+        }
+        return warning;
+    }
+    mapCruiserSeverity(severity) {
+        if (severity === 'error')
+            return 'error';
+        if (severity === 'warn')
+            return 'warning';
+        return 'info';
+    }
+    createArchWarningResult(warnings, violationsByType) {
+        const patternsChecked = Object.keys(violationsByType).map((type) => ARCH_VIOLATION_IDS[type]);
+        return createWarningResult(warnings, patternsChecked);
+    }
+    /**
+     * Get files to cruise based on scope
+     */
+    getFilesToCruise(context, config) {
+        if (config.scope === 'full') {
+            // Return the include patterns for full scan
+            return config.include_patterns;
+        }
+        // Use unified helper for both planless and plan-based modes
+        const files = getFilesFromContext(context, {
+            filter: (f) => this.validator.isAnalysableFile(f, config),
+        });
+        // If no files match, fall back to include patterns
+        if (files.length === 0) {
+            return config.include_patterns;
+        }
+        return files;
+    }
+    /**
+     * Check if a file should be analysed
+     * @internal Reserved for future use
+     */
+    // @ts-expect-error Reserved for future use
+    _isAnalysableFile(filePath, config) {
+        const analysableExtensions = ['.js', '.ts', '.jsx', '.tsx', '.mjs', '.cjs'];
+        const hasValidExtension = analysableExtensions.some((ext) => filePath.endsWith(ext));
+        if (!hasValidExtension)
+            return false;
+        // Check exclusions
+        for (const pattern of config.exclude_patterns) {
+            if (this.matchesGlobPattern(filePath, pattern)) {
+                return false;
+            }
+        }
+        return true;
+    }
+    matchesGlobPattern(filePath, pattern) {
+        // Normalise to forward slashes for consistent cross-platform matching
+        const normalizedPath = filePath.replace(/\\/g, '/');
+        return minimatch(normalizedPath, pattern, { dot: true });
+    }
+    /**
+     * Get default cruise options when no config file exists
+     * @internal Reserved for future use
+     */
+    // @ts-expect-error Reserved for future use
+    _getDefaultCruiseOptions() {
+        return {
+            validate: true,
+            ruleSet: {
+                forbidden: [
+                    {
+                        name: 'no-circular',
+                        severity: 'error',
+                        comment: 'Circular dependencies are not allowed',
+                        from: {},
+                        to: {
+                            circular: true,
+                        },
+                    },
+                    {
+                        name: 'no-orphans',
+                        severity: 'warn',
+                        comment: 'Modules without dependents or dependencies',
+                        from: {
+                            orphan: true,
+                            pathNot: [
+                                '\\.d\\.ts$',
+                                '\\.test\\.(ts|js)$',
+                                '\\.spec\\.(ts|js)$',
+                                'index\\.(ts|js)$',
+                            ],
+                        },
+                        to: {},
+                    },
+                ],
+            },
+        };
+    }
+    /**
+     * Calculate score based on violations
+     * @internal Reserved for future use
+     */
+    // @ts-expect-error Reserved for future use
+    _calculateScore(violations, config) {
+        const violationsByType = {
+            circular: 0,
+            orphan: 0,
+            layer: 0,
+            other: 0,
+        };
+        let totalPenalty = 0;
+        let hasBlockingViolation = false;
+        for (const v of violations) {
+            // Categorise violation
+            if (v.cycle && v.cycle.length > 0) {
+                violationsByType.circular++;
+                if (config.fail_on_circular &&
+                    this.isBlockingSeverity(v.rule.severity, config.severity_threshold)) {
+                    hasBlockingViolation = true;
+                }
+            }
+            else if (v.rule.name.includes('orphan')) {
+                violationsByType.orphan++;
+                if (config.fail_on_orphan &&
+                    this.isBlockingSeverity(v.rule.severity, config.severity_threshold)) {
+                    hasBlockingViolation = true;
+                }
+            }
+            else if (v.rule.name.includes('layer') || v.rule.name.includes('boundary')) {
+                violationsByType.layer++;
+                if (this.isBlockingSeverity(v.rule.severity, config.severity_threshold)) {
+                    hasBlockingViolation = true;
+                }
+            }
+            else {
+                violationsByType.other++;
+                if (this.isBlockingSeverity(v.rule.severity, config.severity_threshold)) {
+                    hasBlockingViolation = true;
+                }
+            }
+            // Calculate penalty
+            totalPenalty += SEVERITY_PENALTIES[v.rule.severity] || 0;
+        }
+        const score = Math.max(0, 100 - totalPenalty);
+        const passed = !hasBlockingViolation;
+        return { score, passed, violationsByType };
+    }
+    /**
+     * Check if a severity level should block the check
+     */
+    isBlockingSeverity(severity, threshold) {
+        const levels = { error: 3, warn: 2, info: 1, ignore: 0 };
+        return levels[severity] >= levels[threshold];
+    }
+    /**
+     * Build human-readable message
+     * @internal Reserved for future use
+     */
+    // @ts-expect-error Reserved for future use
+    _buildMessage(violations, totalCruised, passed) {
+        if (violations.length === 0) {
+            return `Architecture check passed: ${totalCruised} modules analysed, no violations`;
+        }
+        const errorCount = violations.filter((v) => v.rule.severity === 'error').length;
+        const warnCount = violations.filter((v) => v.rule.severity === 'warn').length;
+        const infoCount = violations.filter((v) => v.rule.severity === 'info').length;
+        const parts = [];
+        if (errorCount > 0)
+            parts.push(`${errorCount} error${errorCount > 1 ? 's' : ''}`);
+        if (warnCount > 0)
+            parts.push(`${warnCount} warning${warnCount > 1 ? 's' : ''}`);
+        if (infoCount > 0)
+            parts.push(`${infoCount} info`);
+        const status = passed ? 'passed with issues' : 'failed';
+        return `Architecture check ${status}: ${parts.join(', ')} (${totalCruised} modules analysed)`;
+    }
+    buildArchitectureContext(allViolations, effectiveViolations, summary, violationsByType, baseline, config) {
+        const builder = createContextBuilder();
+        const archViolations = allViolations.map((v) => ({
+            from: v.from,
+            to: v.to,
+            rule: v.rule.name,
+            severity: v.rule.severity,
+            is_circular: v.cycle !== undefined && v.cycle.length > 0,
+            cycle: v.cycle,
+            is_new: baseline ? this.detector.isNewViolation(v, baseline) : true,
+            from_layer: null,
+            to_layer: null,
+        }));
+        builder.setViolations(archViolations);
+        builder.setSummary({
+            total_modules: summary.totalCruised,
+            total_violations: allViolations.length,
+            new_violations: effectiveViolations.length,
+            error_count: summary.error,
+            warn_count: summary.warn,
+            info_count: summary.info,
+            circular_count: violationsByType.circular ?? 0,
+            orphan_count: violationsByType.orphan ?? 0,
+            layer_violation_count: violationsByType.layer ?? 0,
+            baseline_loaded: baseline !== null,
+        });
+        builder.setConfig({
+            config_file: config.config_file,
+            scope: config.scope,
+            severity_threshold: config.severity_threshold,
+        });
+        return builder.build();
+    }
+}

package/dist/gate/checks/command-safety.check.d.ts

@@ -0,0 +1,12 @@
+import { BaseCheck } from '../check.interface.js';
+import type { CheckContext, GateResult } from '../../types/gate.types.js';
+export declare class CommandSafetyCheck extends BaseCheck {
+    name: string;
+    description: string;
+    private parser;
+    constructor();
+    run(context: CheckContext): Promise<GateResult>;
+    private getConfig;
+    private calculateScore;
+}
+//# sourceMappingURL=command-safety.check.d.ts.map

package/dist/gate/checks/command-safety.check.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"command-safety.check.d.ts","sourceRoot":"","sources":["../../../src/gate/checks/command-safety.check.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,SAAS,EAAE,MAAM,uBAAuB,CAAC;AAClD,OAAO,KAAK,EAAE,YAAY,EAAE,UAAU,EAAE,MAAM,2BAA2B,CAAC;AA4I1E,qBAAa,kBAAmB,SAAQ,SAAS;IAC/C,IAAI,SAAoB;IACxB,WAAW,SAAyD;IAEpE,OAAO,CAAC,MAAM,CAAgB;;IAOxB,GAAG,CAAC,OAAO,EAAE,YAAY,GAAG,OAAO,CAAC,UAAU,CAAC;IAsHrD,OAAO,CAAC,SAAS;IAkBjB,OAAO,CAAC,cAAc;CAWvB"}

package/dist/gate/checks/command-safety.check.js

@@ -0,0 +1,230 @@
+import { BaseCheck } from '../check.interface.js';
+import { createDebugger } from '@eddacraft/anvil-core';
+import { CommandParser } from '../parsers/command-parser.js';
+import { findMatchingRule, DEFAULT_GIT_RULES, DEFAULT_FILESYSTEM_RULES } from '../rules/index.js';
+const log = createDebugger('check');
+function extractCommandsFromPlan(context) {
+    const commands = [];
+    if (!context.plan) {
+        return commands;
+    }
+    for (const change of context.plan.proposed_changes) {
+        if (change.type === 'script_execute' && change.description) {
+            const codeBlockMatch = change.description.match(/```(?:bash|sh|shell)?\n([\s\S]*?)```/);
+            if (codeBlockMatch) {
+                const lines = codeBlockMatch[1]
+                    .split('\n')
+                    .filter((line) => line.trim() && !line.startsWith('#'));
+                for (const line of lines) {
+                    commands.push({ command: line.trim(), source: change.path || 'script_execute' });
+                }
+            }
+            else if (!change.description.includes('\n')) {
+                commands.push({ command: change.description, source: change.path || 'script_execute' });
+            }
+        }
+    }
+    return commands;
+}
+function loadRules(config) {
+    let rules = [...DEFAULT_GIT_RULES, ...DEFAULT_FILESYSTEM_RULES];
+    if (config.rules?.disabled && config.rules.disabled.length > 0) {
+        const disabledSet = new Set(config.rules.disabled);
+        rules = rules.filter((r) => !disabledSet.has(r.id));
+    }
+    if (config.rules?.overrides && config.rules.overrides.length > 0) {
+        for (const override of config.rules.overrides) {
+            const ruleIndex = rules.findIndex((r) => r.id === override.id);
+            if (ruleIndex !== -1) {
+                if (override.action === 'disable') {
+                    rules.splice(ruleIndex, 1);
+                }
+                else {
+                    rules[ruleIndex] = {
+                        ...rules[ruleIndex],
+                        ...(override.action && { action: override.action }),
+                        ...(override.severity && { severity: override.severity }),
+                    };
+                }
+            }
+        }
+    }
+    if (config.rules?.custom && config.rules.custom.length > 0) {
+        rules.push(...config.rules.custom);
+    }
+    return rules;
+}
+function formatBlockedMessage(blocked, outputConfig) {
+    if (blocked.length === 0) {
+        return '';
+    }
+    const lines = [`Blocked ${blocked.length} dangerous command(s):`, ''];
+    for (let i = 0; i < blocked.length; i++) {
+        const finding = blocked[i];
+        lines.push(`${i + 1}. ${finding.command}`);
+        if (outputConfig.verbose) {
+            lines.push(`   Reason: ${finding.reason}`);
+        }
+        if (outputConfig.showSuggestions && finding.suggestion) {
+            lines.push(`   Suggestion: ${finding.suggestion}`);
+        }
+        if (outputConfig.showReferences && finding.references && finding.references.length > 0) {
+            lines.push(`   Reference: ${finding.references[0]}`);
+        }
+        lines.push('');
+    }
+    return lines.join('\n');
+}
+function formatWarningMessage(warnings, outputConfig) {
+    if (warnings.length === 0) {
+        return '';
+    }
+    const lines = [`Found ${warnings.length} potentially dangerous command(s):`, ''];
+    for (let i = 0; i < warnings.length; i++) {
+        const finding = warnings[i];
+        lines.push(`${i + 1}. ${finding.command}`);
+        if (outputConfig.verbose) {
+            lines.push(`   Reason: ${finding.reason}`);
+        }
+        if (outputConfig.showSuggestions && finding.suggestion) {
+            lines.push(`   Suggestion: ${finding.suggestion}`);
+        }
+        lines.push('');
+    }
+    return lines.join('\n');
+}
+export class CommandSafetyCheck extends BaseCheck {
+    name = 'command-safety';
+    description = 'Validates shell commands for destructive operations';
+    parser;
+    constructor() {
+        super();
+        this.parser = new CommandParser();
+    }
+    async run(context) {
+        log(`command-safety check starting, workspace=${context.workspace_root}`);
+        const config = this.getConfig(context);
+        if (!config.enabled) {
+            log('command-safety check disabled via config');
+            return this.createResult(true, 'Command safety check disabled', 100, { skipped: true });
+        }
+        const commandSources = extractCommandsFromPlan(context);
+        if (commandSources.length === 0) {
+            log('command-safety check: no commands found in plan');
+            return this.createSuccess('No commands to analyse', 100, {
+                summary: { total: 0, blocked: 0, warned: 0, allowed: 0 },
+            });
+        }
+        log(`command-safety check: analysing ${commandSources.length} command source(s), strict=${config.strict}`);
+        const rules = loadRules(config);
+        log(`command-safety check: loaded ${rules.length} rules`);
+        const blocked = [];
+        const warnings = [];
+        let allowed = 0;
+        let totalAnalysed = 0;
+        for (const { command: rawCommand, source } of commandSources) {
+            const compoundResult = this.parser.parseCompound(rawCommand);
+            for (const parsed of compoundResult.commands) {
+                if (!parsed.command) {
+                    continue;
+                }
+                totalAnalysed++;
+                const matchedRule = findMatchingRule(parsed, rules, {
+                    strict: config.strict,
+                    workingDirectory: config.workingDirectory,
+                    cwd: context.workspace_root,
+                });
+                if (!matchedRule) {
+                    allowed++;
+                    continue;
+                }
+                if (matchedRule.action === 'allow') {
+                    allowed++;
+                    continue;
+                }
+                const finding = {
+                    command: compoundResult.isCompound ? `${parsed.raw} (from: ${rawCommand})` : parsed.raw,
+                    ruleId: matchedRule.id,
+                    category: matchedRule.category,
+                    action: matchedRule.action,
+                    severity: matchedRule.severity,
+                    reason: matchedRule.reason,
+                    suggestion: matchedRule.suggestion,
+                    references: matchedRule.references,
+                    source,
+                };
+                if (matchedRule.action === 'block') {
+                    blocked.push(finding);
+                }
+                else if (matchedRule.action === 'warn') {
+                    warnings.push(finding);
+                }
+            }
+        }
+        const summary = {
+            total: totalAnalysed,
+            blocked: blocked.length,
+            warned: warnings.length,
+            allowed,
+        };
+        const passed = blocked.length === 0;
+        const score = this.calculateScore(summary);
+        log('command-safety check result', {
+            passed,
+            score,
+            total: totalAnalysed,
+            blocked: blocked.length,
+            warned: warnings.length,
+            allowed,
+        });
+        let message;
+        if (passed && warnings.length === 0) {
+            message = `All ${summary.total} command(s) passed safety check`;
+        }
+        else if (passed) {
+            message = `${summary.total} command(s) analysed: ${warnings.length} warning(s)`;
+        }
+        else {
+            message = `Command safety check failed: ${blocked.length} blocked, ${warnings.length} warning(s)`;
+        }
+        return this.createResult(passed, message, score, {
+            blocked,
+            warnings,
+            summary,
+            config: {
+                strict: config.strict ?? false,
+                rulesCount: rules.length,
+                customRulesCount: config.rules?.custom?.length ?? 0,
+                disabledRulesCount: config.rules?.disabled?.length ?? 0,
+            },
+            formattedBlockedMessage: formatBlockedMessage(blocked, config.output),
+            formattedWarningMessage: formatWarningMessage(warnings, config.output),
+        });
+    }
+    getConfig(context) {
+        const checkConfig = (context.check_config ?? {});
+        return {
+            enabled: checkConfig.enabled ?? true,
+            strict: checkConfig.strict ?? false,
+            rules: checkConfig.rules ?? {},
+            workingDirectory: {
+                allowDeleteInCwd: checkConfig.workingDirectory?.allowDeleteInCwd ?? false,
+                tempDirPatterns: checkConfig.workingDirectory?.tempDirPatterns ?? ['/tmp', '/var/tmp'],
+            },
+            output: {
+                verbose: checkConfig.output?.verbose ?? true,
+                showSuggestions: checkConfig.output?.showSuggestions ?? true,
+                showReferences: checkConfig.output?.showReferences ?? true,
+            },
+        };
+    }
+    calculateScore(summary) {
+        if (summary.total === 0) {
+            return 100;
+        }
+        const blockedPenalty = summary.blocked * 25;
+        const warnedPenalty = summary.warned * 5;
+        const totalPenalty = blockedPenalty + warnedPenalty;
+        return Math.max(0, 100 - totalPenalty);
+    }
+}

package/dist/gate/checks/coverage.check.d.ts

@@ -0,0 +1,9 @@
+import { BaseCheck } from '../check.interface.js';
+import { CheckContext, GateResult } from '../../types/gate.types.js';
+export declare class CoverageCheck extends BaseCheck {
+    name: string;
+    description: string;
+    run(context: CheckContext): Promise<GateResult>;
+    private analyzeCoverage;
+}
+//# sourceMappingURL=coverage.check.d.ts.map

package/dist/gate/checks/coverage.check.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"coverage.check.d.ts","sourceRoot":"","sources":["../../../src/gate/checks/coverage.check.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,SAAS,EAAE,MAAM,uBAAuB,CAAC;AAClD,OAAO,EAAE,YAAY,EAAE,UAAU,EAAE,MAAM,2BAA2B,CAAC;AAsCrE,qBAAa,aAAc,SAAQ,SAAS;IAC1C,IAAI,SAAc;IAClB,WAAW,SAAoC;IAEzC,GAAG,CAAC,OAAO,EAAE,YAAY,GAAG,OAAO,CAAC,UAAU,CAAC;IAoDrD,OAAO,CAAC,eAAe;CAyCxB"}