@eddacraft/anvil-runtime 0.1.0

package/dist/export/formatters/prompt-formatter.js

@@ -0,0 +1,256 @@
+/**
+ * Prompt Fragment Formatter
+ *
+ * Formats Anvil constraints as copy-paste system prompt text for manual
+ * AI tool configuration. Optimised for Claude, ChatGPT, and similar tools.
+ *
+ * @module export/formatters/prompt-formatter
+ */
+// =============================================================================
+// Prompt Formatter
+// =============================================================================
+/**
+ * Formats constraints as system prompt text
+ */
+export class PromptFormatter {
+    options;
+    constructor(options = {}) {
+        this.options = {
+            includeBoundaries: true,
+            includeLayers: true,
+            includeAntiPatterns: true,
+            includeConventions: true,
+            includeSuppressions: true,
+            concise: false,
+            ...options,
+        };
+    }
+    /**
+     * Format constraints as prompt text
+     *
+     * @param constraints - Constraints to format
+     * @returns System prompt text
+     */
+    format(constraints) {
+        const sections = [];
+        // Opening instruction
+        sections.push(this.formatOpening());
+        // Architecture boundaries
+        if (this.options.includeBoundaries && constraints.boundaries.length > 0) {
+            sections.push(this.formatBoundaries(constraints));
+        }
+        // Layer definitions
+        if (this.options.includeLayers && constraints.layers.length > 0) {
+            sections.push(this.formatLayers(constraints));
+        }
+        // Anti-patterns
+        if (this.options.includeAntiPatterns && constraints.antiPatterns.length > 0) {
+            sections.push(this.formatAntiPatterns(constraints));
+        }
+        // Conventions
+        if (this.options.includeConventions && constraints.conventions.length > 0) {
+            sections.push(this.formatConventions(constraints));
+        }
+        // Suppressions
+        if (this.options.includeSuppressions && constraints.suppressions.length > 0) {
+            sections.push(this.formatSuppressions(constraints));
+        }
+        return sections.join('\n\n');
+    }
+    /**
+     * Format opening instruction
+     */
+    formatOpening() {
+        if (this.options.concise) {
+            return ('When working on this codebase, follow these architecture rules and conventions. ' +
+                'Flag violations during code generation.');
+        }
+        return ('This codebase has specific architecture boundaries, anti-patterns, and conventions that must be followed. ' +
+            'When generating or modifying code:\n\n' +
+            '1. Respect all architectural boundaries and layer dependencies\n' +
+            '2. Avoid all listed anti-patterns\n' +
+            '3. Follow project conventions consistently\n' +
+            '4. If a boundary violation or anti-pattern is necessary, explain why and suggest alternatives first');
+    }
+    /**
+     * Format architecture boundaries section
+     */
+    formatBoundaries(constraints) {
+        const lines = ['**Architecture Boundaries**'];
+        if (!this.options.concise) {
+            lines.push('These boundaries define which layers can depend on each other:');
+        }
+        lines.push('');
+        for (const boundary of constraints.boundaries) {
+            if (this.options.concise) {
+                lines.push(`- Layer "${boundary.from}" must not depend on "${boundary.to}"`);
+            }
+            else {
+                lines.push(`- **${boundary.name}**: Layer "${boundary.from}" must not depend on "${boundary.to}"`);
+                lines.push(`  ${boundary.message}`);
+                lines.push(`  Severity: ${boundary.severity}`);
+            }
+        }
+        return lines.join('\n');
+    }
+    /**
+     * Format layer definitions section
+     */
+    formatLayers(constraints) {
+        const lines = ['**Layer Definitions**'];
+        if (!this.options.concise) {
+            lines.push('The codebase is organised into these architectural layers:');
+        }
+        lines.push('');
+        for (const layer of constraints.layers) {
+            if (this.options.concise) {
+                lines.push(`- **${layer.name}**: ${layer.patterns.join(', ')}`);
+                if (layer.dependsOn.length > 0) {
+                    lines.push(`  Can depend on: ${layer.dependsOn.join(', ')}`);
+                }
+            }
+            else {
+                lines.push(`- **${layer.name}**`);
+                if (layer.description) {
+                    lines.push(`  ${layer.description}`);
+                }
+                lines.push(`  Files: ${layer.patterns.join(', ')}`);
+                if (layer.dependsOn.length > 0) {
+                    lines.push(`  Allowed dependencies: ${layer.dependsOn.join(', ')}`);
+                }
+                else {
+                    lines.push(`  No dependencies (leaf layer)`);
+                }
+                lines.push('');
+            }
+        }
+        return lines.join('\n');
+    }
+    /**
+     * Format anti-patterns section
+     */
+    formatAntiPatterns(constraints) {
+        const lines = ['**Forbidden Anti-patterns**'];
+        if (!this.options.concise) {
+            lines.push('Never introduce these code patterns:');
+        }
+        lines.push('');
+        // Group by category for better organisation
+        const byCategory = new Map();
+        for (const pattern of constraints.antiPatterns) {
+            if (!byCategory.has(pattern.category)) {
+                byCategory.set(pattern.category, []);
+            }
+            byCategory.get(pattern.category).push(pattern);
+        }
+        for (const [category, patterns] of byCategory) {
+            if (!this.options.concise) {
+                lines.push(`${this.formatCategoryName(category)}:`);
+            }
+            for (const pattern of patterns) {
+                if (this.options.concise) {
+                    lines.push(`- ${pattern.name}: ${pattern.suggestion}`);
+                }
+                else {
+                    lines.push(`- **${pattern.name}** (${pattern.id})`);
+                    lines.push(`  Problem: ${pattern.explanation}`);
+                    lines.push(`  Instead: ${pattern.suggestion}`);
+                    lines.push('');
+                }
+            }
+        }
+        return lines.join('\n');
+    }
+    /**
+     * Format conventions section
+     */
+    formatConventions(constraints) {
+        const lines = ['**Project Conventions**'];
+        if (!this.options.concise) {
+            lines.push('Follow these conventions for consistency:');
+        }
+        lines.push('');
+        for (const convention of constraints.conventions) {
+            lines.push(`- **${this.formatCategoryName(convention.category)}**: ${convention.description}`);
+            if (!this.options.concise && convention.examples && convention.examples.length > 0) {
+                for (const example of convention.examples) {
+                    lines.push(`  • ${example}`);
+                }
+            }
+        }
+        return lines.join('\n');
+    }
+    /**
+     * Format active suppressions section
+     */
+    formatSuppressions(constraints) {
+        const lines = ['**Active Suppressions**'];
+        if (!this.options.concise) {
+            lines.push('These violations are intentionally suppressed. Do not flag or fix them:');
+        }
+        lines.push('');
+        // Group by pattern ID
+        const byPattern = new Map();
+        for (const suppression of constraints.suppressions) {
+            if (!byPattern.has(suppression.patternId)) {
+                byPattern.set(suppression.patternId, []);
+            }
+            byPattern.get(suppression.patternId).push(suppression);
+        }
+        for (const [patternId, suppressions] of byPattern) {
+            if (this.options.concise) {
+                const files = suppressions.map((s) => s.file).join(', ');
+                lines.push(`- ${patternId}: suppressed in ${files}`);
+            }
+            else {
+                lines.push(`${patternId}:`);
+                for (const suppression of suppressions) {
+                    lines.push(`- **${suppression.file}** (${suppression.scope}): ${suppression.reason}`);
+                    if (suppression.expiresAt) {
+                        const expiresAtDate = new Date(suppression.expiresAt);
+                        if (!Number.isNaN(expiresAtDate.getTime())) {
+                            lines.push(`  Expires: ${expiresAtDate.toISOString().slice(0, 10)}`);
+                        }
+                        else {
+                            lines.push(`  Expires: ${suppression.expiresAt}`);
+                        }
+                    }
+                }
+                lines.push('');
+            }
+        }
+        return lines.join('\n');
+    }
+    /**
+     * Format category name for display
+     */
+    formatCategoryName(category) {
+        return category
+            .split('-')
+            .map((word) => word.charAt(0).toUpperCase() + word.slice(1))
+            .join(' ');
+    }
+}
+// =============================================================================
+// Convenience Functions
+// =============================================================================
+/**
+ * Format constraints as prompt fragment with default options
+ *
+ * @param constraints - Constraints to format
+ * @returns Prompt text
+ */
+export function formatAsPrompt(constraints) {
+    const formatter = new PromptFormatter();
+    return formatter.format(constraints);
+}
+/**
+ * Format constraints as concise prompt fragment
+ *
+ * @param constraints - Constraints to format
+ * @returns Concise prompt text
+ */
+export function formatAsConcisePrompt(constraints) {
+    const formatter = new PromptFormatter({ concise: true });
+    return formatter.format(constraints);
+}

package/dist/export/index.d.ts

@@ -0,0 +1,10 @@
+/**
+ * Export module
+ *
+ * Public API for constraint collection and formatting
+ */
+export * from './constraint-collector.js';
+export * from './formatters/llms-txt-formatter.js';
+export * from './formatters/mcp-resource-formatter.js';
+export * from './formatters/prompt-formatter.js';
+//# sourceMappingURL=index.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/export/index.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAEH,cAAc,2BAA2B,CAAC;AAC1C,cAAc,oCAAoC,CAAC;AACnD,cAAc,wCAAwC,CAAC;AACvD,cAAc,kCAAkC,CAAC"}

package/dist/export/index.js

@@ -0,0 +1,9 @@
+/**
+ * Export module
+ *
+ * Public API for constraint collection and formatting
+ */
+export * from './constraint-collector.js';
+export * from './formatters/llms-txt-formatter.js';
+export * from './formatters/mcp-resource-formatter.js';
+export * from './formatters/prompt-formatter.js';

package/dist/gate/check.interface.d.ts

@@ -0,0 +1,15 @@
+import { CheckContext, GateResult } from '../types/gate.types.js';
+export interface Check {
+    name: string;
+    description: string;
+    run(context: CheckContext): Promise<GateResult>;
+}
+export declare abstract class BaseCheck implements Check {
+    abstract name: string;
+    abstract description: string;
+    abstract run(context: CheckContext): Promise<GateResult>;
+    protected createResult(passed: boolean, message: string, score?: number, details?: Record<string, unknown>, error?: string): GateResult;
+    protected createSuccess(message: string, score?: number, details?: Record<string, unknown>): GateResult;
+    protected createFailure(message: string, error?: string, details?: Record<string, unknown>): GateResult;
+}
+//# sourceMappingURL=check.interface.d.ts.map

package/dist/gate/check.interface.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"check.interface.d.ts","sourceRoot":"","sources":["../../src/gate/check.interface.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,YAAY,EAAE,UAAU,EAAE,MAAM,wBAAwB,CAAC;AAElE,MAAM,WAAW,KAAK;IACpB,IAAI,EAAE,MAAM,CAAC;IACb,WAAW,EAAE,MAAM,CAAC;IACpB,GAAG,CAAC,OAAO,EAAE,YAAY,GAAG,OAAO,CAAC,UAAU,CAAC,CAAC;CACjD;AAED,8BAAsB,SAAU,YAAW,KAAK;IAC9C,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;IACtB,QAAQ,CAAC,WAAW,EAAE,MAAM,CAAC;IAE7B,QAAQ,CAAC,GAAG,CAAC,OAAO,EAAE,YAAY,GAAG,OAAO,CAAC,UAAU,CAAC;IAExD,SAAS,CAAC,YAAY,CACpB,MAAM,EAAE,OAAO,EACf,OAAO,EAAE,MAAM,EACf,KAAK,CAAC,EAAE,MAAM,EACd,OAAO,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,EACjC,KAAK,CAAC,EAAE,MAAM,GACb,UAAU;IAWb,SAAS,CAAC,aAAa,CACrB,OAAO,EAAE,MAAM,EACf,KAAK,CAAC,EAAE,MAAM,EACd,OAAO,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAChC,UAAU;IAIb,SAAS,CAAC,aAAa,CACrB,OAAO,EAAE,MAAM,EACf,KAAK,CAAC,EAAE,MAAM,EACd,OAAO,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAChC,UAAU;CAGd"}

package/dist/gate/check.interface.js

@@ -0,0 +1,18 @@
+export class BaseCheck {
+    createResult(passed, message, score, details, error) {
+        return {
+            check: this.name,
+            passed,
+            score,
+            message,
+            details,
+            error,
+        };
+    }
+    createSuccess(message, score, details) {
+        return this.createResult(true, message, score, details);
+    }
+    createFailure(message, error, details) {
+        return this.createResult(false, message, undefined, details, error);
+    }
+}

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

@@ -0,0 +1,27 @@
+/**
+ * Anti-pattern Check - Detect AI escape hatches and code quality issues
+ *
+ * Detects:
+ * - ESLint disable comments (broad and rule-specific)
+ * - Type escapes (any, @ts-ignore, @ts-expect-error)
+ * - Empty catch blocks
+ * - Console statements in production code
+ */
+import { BaseCheck } from '../check.interface.js';
+import { CheckContext, GateResult } from '../../types/gate.types.js';
+export interface AntipatternCheckConfig {
+    patterns?: string[];
+    includeOptIn?: boolean;
+    extensions?: string[];
+    severityThreshold?: 'error' | 'warning' | 'info';
+}
+export declare class AntipatternCheck extends BaseCheck {
+    name: string;
+    description: string;
+    run(context: CheckContext): Promise<GateResult>;
+    private parseConfig;
+    private isScannableFile;
+    private calculateScore;
+    private buildMessage;
+}
+//# sourceMappingURL=antipattern.check.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"antipattern.check.d.ts","sourceRoot":"","sources":["../../../src/gate/checks/antipattern.check.ts"],"names":[],"mappings":"AAAA;;;;;;;;GAQG;AAIH,OAAO,EAAE,SAAS,EAAE,MAAM,uBAAuB,CAAC;AAClD,OAAO,EAAE,YAAY,EAAE,UAAU,EAAuB,MAAM,2BAA2B,CAAC;AAY1F,MAAM,WAAW,sBAAsB;IACrC,QAAQ,CAAC,EAAE,MAAM,EAAE,CAAC;IACpB,YAAY,CAAC,EAAE,OAAO,CAAC;IACvB,UAAU,CAAC,EAAE,MAAM,EAAE,CAAC;IACtB,iBAAiB,CAAC,EAAE,OAAO,GAAG,SAAS,GAAG,MAAM,CAAC;CAClD;AAeD,qBAAa,gBAAiB,SAAQ,SAAS;IAC7C,IAAI,SAAiB;IACrB,WAAW,SAA6D;IAElE,GAAG,CAAC,OAAO,EAAE,YAAY,GAAG,OAAO,CAAC,UAAU,CAAC;IAuErD,OAAO,CAAC,WAAW;IAgBnB,OAAO,CAAC,eAAe;IAIvB,OAAO,CAAC,cAAc;IA2BtB,OAAO,CAAC,YAAY;CAsBrB"}

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

@@ -0,0 +1,140 @@
+/**
+ * Anti-pattern Check - Detect AI escape hatches and code quality issues
+ *
+ * Detects:
+ * - ESLint disable comments (broad and rule-specific)
+ * - Type escapes (any, @ts-ignore, @ts-expect-error)
+ * - Empty catch blocks
+ * - Console statements in production code
+ */
+import { readFileSync } from 'node:fs';
+import * as path from 'node:path';
+import { BaseCheck } from '../check.interface.js';
+import { getFilesFromContext } from '../../types/gate.types.js';
+import { scanFile } from '@eddacraft/anvil-core/antipattern';
+import { createWarningResult, } from '@eddacraft/anvil-core/antipattern';
+import { parseSeverity, createDebugger } from '@eddacraft/anvil-core';
+import { DEFAULT_ANALYSABLE_EXTENSIONS } from '@eddacraft/anvil-core';
+const log = createDebugger('check');
+const DEFAULT_CONFIG = {
+    patterns: [],
+    includeOptIn: false,
+    extensions: DEFAULT_ANALYSABLE_EXTENSIONS,
+    severityThreshold: 'error',
+};
+const SEVERITY_PENALTIES = {
+    error: 15,
+    warning: 5,
+    info: 1,
+};
+export class AntipatternCheck extends BaseCheck {
+    name = 'antipattern';
+    description = 'Detect AI escape hatches and code quality anti-patterns';
+    async run(context) {
+        log(`antipattern check starting, workspace=${context.workspace_root}`);
+        const config = this.parseConfig(context.check_config);
+        log(`antipattern config: severityThreshold=${config.severityThreshold}, patterns=${config.patterns.length}, includeOptIn=${config.includeOptIn}`);
+        try {
+            const files = getFilesFromContext(context, {
+                filter: (f) => this.isScannableFile(f, config),
+            });
+            if (files.length === 0) {
+                log('antipattern check: no scannable files found, returning success');
+                return this.createSuccess('No files to scan for anti-patterns', 100, {
+                    warnings: createWarningResult([], []),
+                    filesScanned: 0,
+                });
+            }
+            log(`antipattern check: scanning ${files.length} files`);
+            const scanOptions = {
+                patterns: config.patterns.length > 0 ? config.patterns : undefined,
+                includeOptIn: config.includeOptIn,
+            };
+            const allWarnings = [];
+            const allPatternsChecked = new Set();
+            let filesScanned = 0;
+            for (const filePath of files) {
+                let content;
+                try {
+                    content = readFileSync(filePath, 'utf-8');
+                }
+                catch {
+                    continue;
+                }
+                const relativePath = path.isAbsolute(filePath)
+                    ? path.relative(context.workspace_root, filePath)
+                    : filePath;
+                const result = scanFile(relativePath, content, scanOptions);
+                allWarnings.push(...result.warnings);
+                result.patternsChecked.forEach((p) => allPatternsChecked.add(p));
+                filesScanned++;
+            }
+            const warningResult = createWarningResult(allWarnings, Array.from(allPatternsChecked));
+            const { score, passed } = this.calculateScore(allWarnings, config);
+            const message = this.buildMessage(warningResult, filesScanned, passed);
+            log(`antipattern check result: passed=${passed}, score=${score}, warnings=${allWarnings.length}, filesScanned=${filesScanned}`);
+            return this.createResult(passed, message, score, {
+                warnings: warningResult,
+                filesScanned,
+                patternsChecked: Array.from(allPatternsChecked),
+            });
+        }
+        catch (error) {
+            log(`antipattern check error: ${error instanceof Error ? error.message : 'Unknown error'}`);
+            return this.createFailure('Anti-pattern check failed unexpectedly', error instanceof Error ? error.message : 'Unknown error');
+        }
+    }
+    parseConfig(checkConfig) {
+        return {
+            patterns: Array.isArray(checkConfig.patterns)
+                ? checkConfig.patterns.filter((p) => typeof p === 'string')
+                : DEFAULT_CONFIG.patterns,
+            includeOptIn: checkConfig.includeOptIn === true,
+            extensions: Array.isArray(checkConfig.extensions)
+                ? checkConfig.extensions.filter((e) => typeof e === 'string')
+                : DEFAULT_CONFIG.extensions,
+            severityThreshold: parseSeverity(checkConfig.severityThreshold, DEFAULT_CONFIG.severityThreshold),
+        };
+    }
+    isScannableFile(filePath, config) {
+        return config.extensions.some((ext) => filePath.endsWith(ext));
+    }
+    calculateScore(warnings, config) {
+        const severityLevels = { error: 3, warning: 2, info: 1 };
+        const threshold = severityLevels[config.severityThreshold];
+        let totalPenalty = 0;
+        let hasBlockingWarning = false;
+        for (const warning of warnings) {
+            if (warning.suppressed)
+                continue;
+            const warningSeverity = severityLevels[warning.severity];
+            if (warningSeverity >= threshold) {
+                hasBlockingWarning = true;
+            }
+            totalPenalty += SEVERITY_PENALTIES[warning.severity] || 0;
+        }
+        const score = Math.max(0, 100 - totalPenalty);
+        const passed = !hasBlockingWarning;
+        return { score, passed };
+    }
+    buildMessage(result, filesScanned, passed) {
+        if (result.warnings.length === 0) {
+            return `Anti-pattern check passed: ${filesScanned} files scanned, no issues found`;
+        }
+        const parts = [];
+        if (result.summary.errors > 0) {
+            parts.push(`${result.summary.errors} error${result.summary.errors > 1 ? 's' : ''}`);
+        }
+        if (result.summary.warnings > 0) {
+            parts.push(`${result.summary.warnings} warning${result.summary.warnings > 1 ? 's' : ''}`);
+        }
+        if (result.summary.info > 0) {
+            parts.push(`${result.summary.info} info`);
+        }
+        if (result.summary.suppressed > 0) {
+            parts.push(`${result.summary.suppressed} suppressed`);
+        }
+        const status = passed ? 'passed with issues' : 'failed';
+        return `Anti-pattern check ${status}: ${parts.join(', ')} (${filesScanned} files scanned)`;
+    }
+}

package/dist/gate/checks/architecture/circular-detector.d.ts

@@ -0,0 +1,33 @@
+/**
+ * Circular Detector - Detect and categorize circular dependencies
+ *
+ * Handles detection and categorization of various violation types from dependency-cruiser.
+ */
+import type { CruiserViolation } from './dependency-analyzer.js';
+import type { ArchitectureBaseline } from '@eddacraft/anvil-core/architecture';
+/**
+ * Categorized violation types
+ */
+export type ViolationType = 'circular' | 'orphan' | 'layer' | 'other';
+/**
+ * Circular detector for analyzing violations
+ */
+export declare class CircularDetector {
+    /**
+     * Categorize a violation by type
+     */
+    categoriseViolation(violation: CruiserViolation): ViolationType;
+    /**
+     * Check if a violation is new compared to baseline
+     */
+    isNewViolation(violation: CruiserViolation, baseline: ArchitectureBaseline): boolean;
+    /**
+     * Count violations by type
+     */
+    countViolationsByType(violations: CruiserViolation[]): Record<string, number>;
+    /**
+     * Filter violations to only new ones based on baseline
+     */
+    filterNewViolations(violations: CruiserViolation[], baseline: ArchitectureBaseline | null): CruiserViolation[];
+}
+//# sourceMappingURL=circular-detector.d.ts.map

package/dist/gate/checks/architecture/circular-detector.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"circular-detector.d.ts","sourceRoot":"","sources":["../../../../src/gate/checks/architecture/circular-detector.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAEH,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,0BAA0B,CAAC;AACjE,OAAO,KAAK,EAAE,oBAAoB,EAAE,MAAM,oCAAoC,CAAC;AAK/E;;GAEG;AACH,MAAM,MAAM,aAAa,GAAG,UAAU,GAAG,QAAQ,GAAG,OAAO,GAAG,OAAO,CAAC;AAEtE;;GAEG;AACH,qBAAa,gBAAgB;IAC3B;;OAEG;IACH,mBAAmB,CAAC,SAAS,EAAE,gBAAgB,GAAG,aAAa;IAa/D;;OAEG;IACH,cAAc,CAAC,SAAS,EAAE,gBAAgB,EAAE,QAAQ,EAAE,oBAAoB,GAAG,OAAO;IAYpF;;OAEG;IACH,qBAAqB,CAAC,UAAU,EAAE,gBAAgB,EAAE,GAAG,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC;IAiB7E;;OAEG;IACH,mBAAmB,CACjB,UAAU,EAAE,gBAAgB,EAAE,EAC9B,QAAQ,EAAE,oBAAoB,GAAG,IAAI,GACpC,gBAAgB,EAAE;CAYtB"}

package/dist/gate/checks/architecture/circular-detector.js

@@ -0,0 +1,71 @@
+/**
+ * Circular Detector - Detect and categorize circular dependencies
+ *
+ * Handles detection and categorization of various violation types from dependency-cruiser.
+ */
+import { createDebugger } from '@eddacraft/anvil-core';
+const log = createDebugger('check');
+/**
+ * Circular detector for analyzing violations
+ */
+export class CircularDetector {
+    /**
+     * Categorize a violation by type
+     */
+    categoriseViolation(violation) {
+        if (violation.cycle && violation.cycle.length > 0) {
+            return 'circular';
+        }
+        if (violation.rule.name.includes('orphan')) {
+            return 'orphan';
+        }
+        if (violation.rule.name.includes('layer') || violation.rule.name.includes('boundary')) {
+            return 'layer';
+        }
+        return 'other';
+    }
+    /**
+     * Check if a violation is new compared to baseline
+     */
+    isNewViolation(violation, baseline) {
+        const baselineViolations = baseline.baseline_snapshot.violations;
+        return !baselineViolations.some((bv) => {
+            const filesMatch = bv.from_file === violation.from && bv.to_file === violation.to;
+            if (!filesMatch)
+                return false;
+            if (bv.rule) {
+                return bv.rule === violation.rule.name;
+            }
+            return true;
+        });
+    }
+    /**
+     * Count violations by type
+     */
+    countViolationsByType(violations) {
+        const violationsByType = {
+            circular: 0,
+            orphan: 0,
+            layer: 0,
+            other: 0,
+        };
+        for (const v of violations) {
+            const type = this.categoriseViolation(v);
+            violationsByType[type]++;
+        }
+        log('circular-detector: violation counts by type', { violationsByType });
+        return violationsByType;
+    }
+    /**
+     * Filter violations to only new ones based on baseline
+     */
+    filterNewViolations(violations, baseline) {
+        if (!baseline) {
+            log(`circular-detector: no baseline, all ${violations.length} violations treated as new`);
+            return violations;
+        }
+        const newViolations = violations.filter((v) => this.isNewViolation(v, baseline));
+        log(`circular-detector: filtered ${violations.length} violations to ${newViolations.length} new (baseline has ${baseline.baseline_snapshot.violations.length})`);
+        return newViolations;
+    }
+}