@eddacraft/anvil-runtime 0.1.0

package/dist/gate/formatters/command-safety-formatter.d.ts

@@ -0,0 +1,10 @@
+import type { CommandSafetyFinding, CommandAnalysisSummary, CommandSafetyOutputConfig } from '../rules/types.js';
+export interface FormatOptions {
+    verbose?: boolean;
+    showSuggestions?: boolean;
+    showReferences?: boolean;
+}
+export declare function formatBlockedCommands(blocked: CommandSafetyFinding[], options?: FormatOptions | CommandSafetyOutputConfig): string;
+export declare function formatWarningCommands(warnings: CommandSafetyFinding[], options?: FormatOptions | CommandSafetyOutputConfig): string;
+export declare function formatSummary(summary: CommandAnalysisSummary): string;
+//# sourceMappingURL=command-safety-formatter.d.ts.map

package/dist/gate/formatters/command-safety-formatter.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"command-safety-formatter.d.ts","sourceRoot":"","sources":["../../../src/gate/formatters/command-safety-formatter.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EACV,oBAAoB,EACpB,sBAAsB,EACtB,yBAAyB,EAC1B,MAAM,mBAAmB,CAAC;AAK3B,MAAM,WAAW,aAAa;IAC5B,OAAO,CAAC,EAAE,OAAO,CAAC;IAClB,eAAe,CAAC,EAAE,OAAO,CAAC;IAC1B,cAAc,CAAC,EAAE,OAAO,CAAC;CAC1B;AAQD,wBAAgB,qBAAqB,CACnC,OAAO,EAAE,oBAAoB,EAAE,EAC/B,OAAO,CAAC,EAAE,aAAa,GAAG,yBAAyB,GAClD,MAAM,CAyBR;AAED,wBAAgB,qBAAqB,CACnC,QAAQ,EAAE,oBAAoB,EAAE,EAChC,OAAO,CAAC,EAAE,aAAa,GAAG,yBAAyB,GAClD,MAAM,CAsBR;AAED,wBAAgB,aAAa,CAAC,OAAO,EAAE,sBAAsB,GAAG,MAAM,CAmBrE"}

package/dist/gate/formatters/command-safety-formatter.js

@@ -0,0 +1,64 @@
+import { createDebugger } from '@eddacraft/anvil-core';
+const debug = createDebugger('gate');
+const DEFAULT_FORMAT_OPTIONS = {
+    verbose: true,
+    showSuggestions: true,
+    showReferences: true,
+};
+export function formatBlockedCommands(blocked, options) {
+    debug(`formatBlockedCommands: count=${blocked.length}`);
+    if (blocked.length === 0) {
+        return '';
+    }
+    const opts = { ...DEFAULT_FORMAT_OPTIONS, ...options };
+    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 (opts.verbose) {
+            lines.push(`   Reason: ${finding.reason}`);
+        }
+        if (opts.showSuggestions && finding.suggestion) {
+            lines.push(`   Suggestion: ${finding.suggestion}`);
+        }
+        if (opts.showReferences && finding.references && finding.references.length > 0) {
+            lines.push(`   Reference: ${finding.references[0]}`);
+        }
+        lines.push('');
+    }
+    return lines.join('\n');
+}
+export function formatWarningCommands(warnings, options) {
+    debug(`formatWarningCommands: count=${warnings.length}`);
+    if (warnings.length === 0) {
+        return '';
+    }
+    const opts = { ...DEFAULT_FORMAT_OPTIONS, ...options };
+    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 (opts.verbose) {
+            lines.push(`   Reason: ${finding.reason}`);
+        }
+        if (opts.showSuggestions && finding.suggestion) {
+            lines.push(`   Suggestion: ${finding.suggestion}`);
+        }
+        lines.push('');
+    }
+    return lines.join('\n');
+}
+export function formatSummary(summary) {
+    debug(`formatSummary: total=${summary.total} blocked=${summary.blocked} warned=${summary.warned}`);
+    const { total, blocked, warned } = summary;
+    if (total === 0) {
+        return 'No commands to analyse';
+    }
+    if (blocked === 0 && warned === 0) {
+        return `All ${total} command(s) passed safety check`;
+    }
+    if (blocked === 0) {
+        return `${total} command(s) analysed: ${warned} warning(s)`;
+    }
+    return `Command safety check failed: ${blocked} blocked, ${warned} warning(s) of ${total} total`;
+}

package/dist/gate/formatters/index.d.ts

@@ -0,0 +1,2 @@
+export { formatBlockedCommands, formatWarningCommands, formatSummary, type FormatOptions, } from './command-safety-formatter.js';
+//# sourceMappingURL=index.d.ts.map

package/dist/gate/formatters/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/gate/formatters/index.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,qBAAqB,EACrB,qBAAqB,EACrB,aAAa,EACb,KAAK,aAAa,GACnB,MAAM,+BAA+B,CAAC"}

package/dist/gate/formatters/index.js

@@ -0,0 +1 @@
+export { formatBlockedCommands, formatWarningCommands, formatSummary, } from './command-safety-formatter.js';

package/dist/gate/gate-config.d.ts

@@ -0,0 +1,44 @@
+import { GateConfig, GateCheck } from '../types/gate.types.js';
+import { type WatchConfig } from '../watch/types.js';
+export interface ConfigLoadResult {
+    config: GateConfig;
+    path: string | null;
+    isDefault: boolean;
+    errors: string[];
+}
+export declare class GateConfigManager {
+    private configPath;
+    private workspaceRoot;
+    constructor(workspaceRoot: string);
+    /**
+     * Find the first existing config file from priority locations
+     */
+    private findConfigFile;
+    /**
+     * Get the path where config will be saved (prefers existing location, defaults to .anvilrc)
+     */
+    getConfigPath(): string;
+    /**
+     * Get all possible config locations
+     */
+    getConfigLocations(): string[];
+    loadConfig(): GateConfig;
+    /**
+     * Load configuration with detailed result including path and validation errors
+     */
+    loadConfigWithDetails(): ConfigLoadResult;
+    saveConfig(config: GateConfig): void;
+    getDefaultConfig(): GateConfig;
+    /**
+     * Validate and normalise configuration with detailed error tracking
+     */
+    private validateAndNormalizeConfigWithErrors;
+    /**
+     * Get watch configuration (parsed and validated)
+     */
+    getWatchConfig(): WatchConfig | undefined;
+    updateCheck(name: string, updates: Partial<GateCheck>): void;
+    enableCheck(name: string): void;
+    disableCheck(name: string): void;
+}
+//# sourceMappingURL=gate-config.d.ts.map

package/dist/gate/gate-config.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"gate-config.d.ts","sourceRoot":"","sources":["../../src/gate/gate-config.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,UAAU,EAAE,SAAS,EAA6B,MAAM,wBAAwB,CAAC;AAG1F,OAAO,EAAqB,KAAK,WAAW,EAAE,MAAM,mBAAmB,CAAC;AAaxE,MAAM,WAAW,gBAAgB;IAC/B,MAAM,EAAE,UAAU,CAAC;IACnB,IAAI,EAAE,MAAM,GAAG,IAAI,CAAC;IACpB,SAAS,EAAE,OAAO,CAAC;IACnB,MAAM,EAAE,MAAM,EAAE,CAAC;CAClB;AAED,qBAAa,iBAAiB;IAC5B,OAAO,CAAC,UAAU,CAAuB;IACzC,OAAO,CAAC,aAAa,CAAS;gBAElB,aAAa,EAAE,MAAM;IAMjC;;OAEG;IACH,OAAO,CAAC,cAAc;IAYtB;;OAEG;IACH,aAAa,IAAI,MAAM;IAIvB;;OAEG;IACH,kBAAkB,IAAI,MAAM,EAAE;IAI9B,UAAU,IAAI,UAAU;IAKxB;;OAEG;IACH,qBAAqB,IAAI,gBAAgB;IA0CzC,UAAU,CAAC,MAAM,EAAE,UAAU,GAAG,IAAI;IAcpC,gBAAgB,IAAI,UAAU;IAuE9B;;OAEG;IACH,OAAO,CAAC,oCAAoC;IA2J5C;;OAEG;IACH,cAAc,IAAI,WAAW,GAAG,SAAS;IAMzC,WAAW,CAAC,IAAI,EAAE,MAAM,EAAE,OAAO,EAAE,OAAO,CAAC,SAAS,CAAC,GAAG,IAAI;IAkB5D,WAAW,CAAC,IAAI,EAAE,MAAM,GAAG,IAAI;IAI/B,YAAY,CAAC,IAAI,EAAE,MAAM,GAAG,IAAI;CAGjC"}

package/dist/gate/gate-config.js

@@ -0,0 +1,334 @@
+import { readFileSync, existsSync, writeFileSync, mkdirSync } from 'node:fs';
+import { join, dirname } from 'node:path';
+import { WatchConfigSchema } from '../watch/types.js';
+import { createDebugger } from '@eddacraft/anvil-core';
+const debug = createDebugger('gate');
+/**
+ * Configuration file locations in priority order
+ */
+const CONFIG_LOCATIONS = [
+    '.anvilrc', // Root level (primary)
+    '.anvil/config.json', // .anvil directory (alternative)
+];
+export class GateConfigManager {
+    configPath = null;
+    workspaceRoot;
+    constructor(workspaceRoot) {
+        this.workspaceRoot = workspaceRoot;
+        this.configPath = this.findConfigFile();
+        debug(`GateConfigManager: workspace=${workspaceRoot} configPath=${this.configPath}`);
+    }
+    /**
+     * Find the first existing config file from priority locations
+     */
+    findConfigFile() {
+        for (const location of CONFIG_LOCATIONS) {
+            const fullPath = join(this.workspaceRoot, location);
+            if (existsSync(fullPath)) {
+                debug(`findConfigFile: found ${fullPath}`);
+                return fullPath;
+            }
+        }
+        debug('findConfigFile: no config found, will use defaults');
+        return null;
+    }
+    /**
+     * Get the path where config will be saved (prefers existing location, defaults to .anvilrc)
+     */
+    getConfigPath() {
+        return this.configPath || join(this.workspaceRoot, '.anvilrc');
+    }
+    /**
+     * Get all possible config locations
+     */
+    getConfigLocations() {
+        return CONFIG_LOCATIONS.map((loc) => join(this.workspaceRoot, loc));
+    }
+    loadConfig() {
+        const result = this.loadConfigWithDetails();
+        return result.config;
+    }
+    /**
+     * Load configuration with detailed result including path and validation errors
+     */
+    loadConfigWithDetails() {
+        debug(`loadConfigWithDetails: path=${this.configPath}`);
+        if (!this.configPath) {
+            debug('loadConfigWithDetails: using default config');
+            return {
+                config: this.getDefaultConfig(),
+                path: null,
+                isDefault: true,
+                errors: [],
+            };
+        }
+        try {
+            const content = readFileSync(this.configPath, 'utf-8');
+            const rawConfig = JSON.parse(content);
+            const { config, errors } = this.validateAndNormalizeConfigWithErrors(rawConfig);
+            debug(`loadConfigWithDetails: loaded ${config.checks.length} checks, ${errors.length} errors`);
+            return {
+                config,
+                path: this.configPath,
+                isDefault: false,
+                errors,
+            };
+        }
+        catch (error) {
+            const errorMessage = error instanceof Error ? error.message : 'Unknown error';
+            console.warn(`Failed to load gate config from ${this.configPath}, using defaults:`, errorMessage);
+            return {
+                config: this.getDefaultConfig(),
+                path: this.configPath,
+                isDefault: true,
+                errors: [`Failed to parse config: ${errorMessage}`],
+            };
+        }
+    }
+    saveConfig(config) {
+        const savePath = this.getConfigPath();
+        debug(`saveConfig: path=${savePath} checks=${config.checks.length}`);
+        const content = JSON.stringify(config, null, 2);
+        // Ensure directory exists before writing file
+        const dir = dirname(savePath);
+        if (!existsSync(dir)) {
+            mkdirSync(dir, { recursive: true });
+        }
+        writeFileSync(savePath, content, 'utf-8');
+        // Update configPath to the saved location
+        this.configPath = savePath;
+    }
+    getDefaultConfig() {
+        return {
+            version: 1,
+            checks: [
+                {
+                    name: 'eslint',
+                    description: 'Code quality checks',
+                    enabled: true,
+                    config: {
+                        min_score: 80,
+                    },
+                },
+                {
+                    name: 'coverage',
+                    description: 'Test coverage validation',
+                    enabled: true,
+                    config: {
+                        min_score: 80,
+                        thresholds: {
+                            lines: 80,
+                            functions: 80,
+                            branches: 80,
+                            statements: 80,
+                        },
+                    },
+                },
+                {
+                    name: 'secret',
+                    description: 'Secret scanning',
+                    enabled: true,
+                    config: {},
+                },
+                {
+                    name: 'dependency',
+                    description: 'Dependency vulnerability scanning',
+                    enabled: true,
+                    config: {
+                        min_severity: 'moderate',
+                        fail_on_critical: true,
+                        fail_on_high: true,
+                        fail_on_moderate: false,
+                    },
+                },
+                {
+                    name: 'policy',
+                    description: 'OPA/Rego policy evaluation',
+                    enabled: false, // Disabled by default until policies are configured
+                    config: {
+                        policy_dir: '.anvil/policies',
+                        severity_threshold: 'error',
+                    },
+                },
+                {
+                    name: 'architecture',
+                    description: 'Architecture validation using dependency-cruiser',
+                    enabled: false, // Disabled by default until dependency-cruiser is installed
+                    config: {
+                        config_file: '.anvil/dependency-cruiser.js',
+                        scope: 'affected',
+                        severity_threshold: 'error',
+                        fail_on_circular: true,
+                        fail_on_orphan: false,
+                    },
+                },
+            ],
+            thresholds: {
+                overall_score: 80,
+            },
+        };
+    }
+    /**
+     * Validate and normalise configuration with detailed error tracking
+     */
+    validateAndNormalizeConfigWithErrors(config) {
+        const errors = [];
+        // Type guard to ensure config is an object
+        if (typeof config !== 'object' || config === null) {
+            errors.push('Configuration must be an object');
+            return { config: this.getDefaultConfig(), errors };
+        }
+        const configObj = config;
+        // Validate version
+        if (!configObj.version) {
+            errors.push('Missing required field: version (defaulting to 1)');
+            configObj.version = 1;
+        }
+        else if (typeof configObj.version !== 'number') {
+            errors.push(`Invalid version type: expected number, got ${typeof configObj.version}`);
+            configObj.version = 1;
+        }
+        // Validate checks
+        if (!configObj.checks) {
+            errors.push('Missing required field: checks (defaulting to empty array)');
+            configObj.checks = [];
+        }
+        else if (!Array.isArray(configObj.checks)) {
+            errors.push(`Invalid checks type: expected array, got ${typeof configObj.checks}`);
+            configObj.checks = [];
+        }
+        // Validate thresholds
+        if (!configObj.thresholds) {
+            errors.push('Missing required field: thresholds (using default overall_score: 80)');
+            configObj.thresholds = { overall_score: 80 };
+        }
+        else if (typeof configObj.thresholds !== 'object' || configObj.thresholds === null) {
+            errors.push(`Invalid thresholds type: expected object, got ${typeof configObj.thresholds}`);
+            configObj.thresholds = { overall_score: 80 };
+        }
+        // Validate each check
+        const checksArray = Array.isArray(configObj.checks) ? configObj.checks : [];
+        const validatedChecks = checksArray.map((check, index) => {
+            if (typeof check !== 'object' || check === null) {
+                errors.push(`checks[${index}]: expected object, got ${typeof check}`);
+                return {
+                    name: 'unknown',
+                    description: '',
+                    enabled: false,
+                    config: {},
+                };
+            }
+            const checkObj = check;
+            // Validate check name
+            if (typeof checkObj.name !== 'string' || !checkObj.name) {
+                errors.push(`checks[${index}].name: missing or invalid name`);
+            }
+            // Validate check config if present
+            if (checkObj.config !== undefined &&
+                (typeof checkObj.config !== 'object' || checkObj.config === null)) {
+                errors.push(`checks[${index}].config: expected object, got ${typeof checkObj.config}`);
+            }
+            return {
+                name: typeof checkObj.name === 'string' ? checkObj.name : 'unknown',
+                description: typeof checkObj.description === 'string' ? checkObj.description : '',
+                enabled: checkObj.enabled !== false,
+                config: typeof checkObj.config === 'object' && checkObj.config !== null
+                    ? checkObj.config
+                    : {},
+            };
+        });
+        // Parse watch config if present
+        let watchConfig;
+        if (configObj.watch !== undefined) {
+            try {
+                watchConfig = WatchConfigSchema.parse(configObj.watch);
+            }
+            catch (watchError) {
+                errors.push(`watch: invalid configuration - ${watchError instanceof Error ? watchError.message : 'unknown error'}`);
+            }
+        }
+        // Pass through policy config if present (bundles, verification settings)
+        let policyConfig;
+        if (configObj.policy !== undefined &&
+            typeof configObj.policy === 'object' &&
+            configObj.policy !== null) {
+            policyConfig = configObj.policy;
+        }
+        // Parse stack config if present (STACK-012)
+        let stackConfig;
+        if (configObj.stack !== undefined &&
+            typeof configObj.stack === 'object' &&
+            configObj.stack !== null) {
+            const stack = configObj.stack;
+            // Validate layer configs
+            for (const layer of ['kindling', 'ember', 'edda']) {
+                if (stack[layer] !== undefined) {
+                    if (typeof stack[layer] !== 'object' || stack[layer] === null) {
+                        errors.push(`stack.${layer}: expected object`);
+                    }
+                    else {
+                        const layerConfig = stack[layer];
+                        if (layerConfig.enabled !== undefined && typeof layerConfig.enabled !== 'boolean') {
+                            errors.push(`stack.${layer}.enabled: expected boolean`);
+                        }
+                    }
+                }
+            }
+            // Validate validation config
+            if (stack.validation !== undefined) {
+                if (typeof stack.validation !== 'object' || stack.validation === null) {
+                    errors.push('stack.validation: expected object');
+                }
+                else {
+                    const validation = stack.validation;
+                    for (const key of ['check_provenance_integrity', 'check_schema_compatibility']) {
+                        if (validation[key] !== undefined && typeof validation[key] !== 'boolean') {
+                            errors.push(`stack.validation.${key}: expected boolean`);
+                        }
+                    }
+                }
+            }
+            stackConfig = stack;
+        }
+        const validatedConfig = {
+            version: configObj.version,
+            checks: validatedChecks,
+            thresholds: configObj.thresholds,
+            global_config: configObj.global_config,
+            watch: watchConfig,
+            policy: policyConfig,
+            stack: stackConfig,
+        };
+        return { config: validatedConfig, errors };
+    }
+    /**
+     * Get watch configuration (parsed and validated)
+     */
+    getWatchConfig() {
+        const config = this.loadConfig();
+        // Internal config may have defaults applied - cast to base type
+        return config.watch;
+    }
+    updateCheck(name, updates) {
+        const config = this.loadConfig();
+        const checkIndex = config.checks.findIndex((c) => c.name === name);
+        if (checkIndex >= 0) {
+            config.checks[checkIndex] = { ...config.checks[checkIndex], ...updates };
+        }
+        else {
+            config.checks.push({
+                name,
+                description: updates.description || '',
+                enabled: updates.enabled !== false,
+                config: updates.config || {},
+            });
+        }
+        this.saveConfig(config);
+    }
+    enableCheck(name) {
+        this.updateCheck(name, { enabled: true });
+    }
+    disableCheck(name) {
+        this.updateCheck(name, { enabled: false });
+    }
+}

package/dist/gate/gate-runner.d.ts

@@ -0,0 +1,160 @@
+import { Check } from './check.interface.js';
+import { GateConfig, GateResult, GateRunResult, PlanData } from '../types/gate.types.js';
+import { type ProvenanceRecord } from '@eddacraft/anvil-core';
+import type { CacheProvider } from '../cache/types.js';
+import type { Warning, WarningResult } from '@eddacraft/anvil-core/antipattern';
+import { type SuppressionStats, SuppressionStore } from '@eddacraft/anvil-core/suppression';
+/**
+ * Progress event types
+ */
+export type ProgressEventType = 'check:start' | 'check:complete' | 'check:error';
+/**
+ * Progress event data
+ */
+export interface ProgressEvent {
+    type: ProgressEventType;
+    checkName: string;
+    /** Current check index (1-based) */
+    current: number;
+    /** Total number of checks to run */
+    total: number;
+    /** Result (only for check:complete and check:error) */
+    result?: GateResult;
+    /** Whether result was from cache */
+    cached?: boolean;
+    /** Execution time in ms */
+    executionTimeMs?: number;
+}
+/**
+ * Progress callback function
+ */
+export type ProgressCallback = (event: ProgressEvent) => void;
+/**
+ * Provenance recording options — controls whether gate execution
+ * creates a persistent provenance record in the .anvil directory
+ */
+export interface ProvenanceOptions {
+    /** Enable provenance recording (default: false) */
+    enabled: boolean;
+    /** What triggered this gate run */
+    trigger: 'manual' | 'pre-commit' | 'ci' | 'watch' | 'api';
+    /** Scope of the check */
+    scope: 'directory' | 'staged' | 'files' | 'plan';
+    /** Files being checked (for the provenance record) */
+    filesChecked?: string[];
+    /** Associated plan ID if plan-driven */
+    planId?: string;
+}
+/**
+ * Options for running gates
+ */
+export interface GateRunOptions {
+    /** Checks to skip */
+    skipChecks?: string[];
+    /** Only run these checks */
+    onlyChecks?: string[];
+    /** Stop on first failure */
+    failFast?: boolean;
+    /** Cache provider (defaults to NullCacheProvider) */
+    cache?: CacheProvider;
+    /** Maximum parallel checks (0 = sequential, undefined = all parallel) */
+    parallelLimit?: number;
+    /** Force bypass cache for this run */
+    noCache?: boolean;
+    /** Progress callback for real-time updates */
+    onProgress?: ProgressCallback;
+    /** Full codebase scan mode (no plan-based scoping) */
+    fullScan?: boolean;
+    /** Provenance recording options */
+    provenance?: ProvenanceOptions;
+}
+/**
+ * Extended gate result with cache metadata
+ */
+export interface GateRunResultWithCache extends GateRunResult {
+    /** Cache statistics for this run */
+    cacheStats?: {
+        /** Number of cache hits */
+        hits: number;
+        /** Number of cache misses */
+        misses: number;
+        /** Estimated time saved by cache hits (ms) */
+        timeSavedMs: number;
+    };
+    /** Execution timing */
+    timing?: {
+        /** Total execution time (ms) */
+        totalMs: number;
+        /** Per-check timing */
+        checks: Record<string, number>;
+    };
+    /** Provenance record ID (present when provenance recording is enabled) */
+    provenance_id?: string;
+    /** Full provenance record (present when provenance recording is enabled) */
+    provenanceRecord?: ProvenanceRecord;
+}
+/**
+ * Options for analyzeFiles() - planless file analysis mode
+ */
+export interface AnalyzeOptions {
+    /** Cache provider (defaults to NullCacheProvider) */
+    cache?: CacheProvider;
+    /** Force bypass cache for this run */
+    noCache?: boolean;
+    /** Which checks to run (defaults to ['architecture', 'antipattern']) */
+    checks?: ('architecture' | 'antipattern')[];
+    /** Max parallel checks (1 = sequential) */
+    parallelLimit?: number;
+    /** Check-specific configuration */
+    checkConfig?: Record<string, unknown>;
+    /** Optional hook for streaming warnings to IDEs or reporters */
+    onWarning?: (warning: Warning) => void;
+    /** Optional hook invoked when analysis completes */
+    onResult?: (result: AnalyzeResult) => void;
+    /** Enable suppression checking (default: true) */
+    suppressions?: boolean;
+    /** Pre-configured suppression store (created internally if not provided) */
+    suppressionStore?: SuppressionStore;
+    /** Provenance recording options */
+    provenance?: ProvenanceOptions;
+}
+/**
+ * Result from analyzeFiles() - focused on warnings
+ */
+export interface AnalyzeResult {
+    /** Aggregated warnings from all checks */
+    warnings: WarningResult;
+    /** Execution timing in ms */
+    executionTimeMs: number;
+    /** Which checks were run */
+    checksRun: string[];
+    /** Whether any blocking warnings (severity: error, not suppressed) exist */
+    hasBlockingWarnings: boolean;
+    /** Suppression statistics (only present if suppressions enabled) */
+    suppressionStats?: SuppressionStats;
+    /** Provenance record ID (present when provenance recording is enabled) */
+    provenance_id?: string;
+}
+/**
+ * Creates a minimal valid PlanData object for use in planless/full-codebase
+ * gate runs where no real plan exists. Avoids unsafe double type-casts.
+ */
+export declare function createEmptyPlan(): PlanData;
+export declare class GateRunner {
+    private checks;
+    private defaultCache;
+    constructor();
+    /**
+     * Set default cache provider
+     */
+    setDefaultCache(cache: CacheProvider): void;
+    registerCheck(check: Check): void;
+    unregisterCheck(name: string): void;
+    getAvailableChecks(): string[];
+    analyzeFiles(files: string[], workspaceRoot: string, options?: AnalyzeOptions): Promise<AnalyzeResult>;
+    runGate(plan: PlanData, config: GateConfig, workspaceRoot: string, options?: GateRunOptions): Promise<GateRunResultWithCache>;
+    private executeChecks;
+    private runCheckWithCache;
+    private registerDefaultChecks;
+}
+//# sourceMappingURL=gate-runner.d.ts.map

package/dist/gate/gate-runner.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"gate-runner.d.ts","sourceRoot":"","sources":["../../src/gate/gate-runner.ts"],"names":[],"mappings":"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"}