@eddacraft/anvil-runtime 0.1.0

package/dist/export/formatters/llms-txt-formatter.js

@@ -0,0 +1,249 @@
+/**
+ * llms.txt Formatter
+ *
+ * Formats Anvil constraints as llms.txt markdown for AI tool consumption.
+ *
+ * llms.txt is an emerging community standard for providing AI-readable
+ * documentation and constraints. See: https://mintlify.com/blog/simplifying-docs-with-llms-txt
+ *
+ * @module export/formatters/llms-txt-formatter
+ */
+// =============================================================================
+// llms.txt Formatter
+// =============================================================================
+/**
+ * Formats constraints as llms.txt markdown
+ */
+export class LlmsTxtFormatter {
+    options;
+    constructor(options = {}) {
+        this.options = {
+            includeMetadata: true,
+            includeBoundaries: true,
+            includeAntiPatterns: true,
+            includeConventions: true,
+            includeLayers: true,
+            includeSuppressions: true,
+            ...options,
+        };
+    }
+    /**
+     * Format constraints as llms.txt markdown
+     *
+     * @param constraints - Constraints to format
+     * @returns llms.txt markdown string
+     */
+    format(constraints) {
+        const sections = [];
+        // Title
+        sections.push('# Anvil Architecture Constraints\n');
+        // Metadata
+        if (this.options.includeMetadata) {
+            sections.push(this.formatMetadata(constraints));
+        }
+        // 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');
+    }
+    /**
+     * Format metadata section
+     */
+    formatMetadata(constraints) {
+        const lines = [
+            '> **Generated:** ' + new Date(constraints.metadata.collectedAt).toLocaleString(),
+            '> **Workspace:** ' + constraints.metadata.workspaceRoot,
+            '> **Has Baseline:** ' + (constraints.metadata.hasBaseline ? 'Yes' : 'No'),
+            '',
+        ];
+        return lines.join('\n');
+    }
+    /**
+     * Format architecture boundaries section
+     */
+    formatBoundaries(constraints) {
+        const lines = ['## Boundary Rules\n'];
+        lines.push('These architectural boundaries must be respected. Violations will be flagged as warnings or errors.\n');
+        for (const boundary of constraints.boundaries) {
+            const severityEmoji = this.getSeverityEmoji(boundary.severity);
+            lines.push(`- ${severityEmoji} **${boundary.name}**`);
+            lines.push(`  - From: \`${boundary.from}\``);
+            lines.push(`  - To: \`${boundary.to}\``);
+            lines.push(`  - Rule: ${boundary.message}`);
+            lines.push('');
+        }
+        return lines.join('\n');
+    }
+    /**
+     * Format layer definitions section
+     */
+    formatLayers(constraints) {
+        const lines = ['## Layer Definitions\n'];
+        lines.push('The codebase is organised into architectural layers. Each layer has specific responsibilities and dependencies.\n');
+        for (const layer of constraints.layers) {
+            lines.push(`### ${layer.name}\n`);
+            if (layer.description) {
+                lines.push(`${layer.description}\n`);
+            }
+            lines.push('**Patterns:**');
+            for (const pattern of layer.patterns) {
+                lines.push(`- \`${pattern}\``);
+            }
+            lines.push('');
+            if (layer.dependsOn.length > 0) {
+                lines.push('**Can depend on:**');
+                for (const dep of layer.dependsOn) {
+                    lines.push(`- ${dep}`);
+                }
+            }
+            else {
+                lines.push('**Dependencies:** None (leaf layer)');
+            }
+            lines.push('');
+        }
+        return lines.join('\n');
+    }
+    /**
+     * Format anti-patterns section
+     */
+    formatAntiPatterns(constraints) {
+        const lines = ['## Anti-patterns (Blocked)\n'];
+        lines.push('These code patterns are considered anti-patterns and should be avoided. ' +
+            'Anvil will flag them during code review.\n');
+        // Group by category
+        const byCategory = new Map();
+        for (const pattern of constraints.antiPatterns) {
+            const category = pattern.category;
+            if (!byCategory.has(category)) {
+                byCategory.set(category, []);
+            }
+            byCategory.get(category).push(pattern);
+        }
+        // Format each category
+        for (const [category, patterns] of byCategory) {
+            lines.push(`### ${this.formatCategoryName(category)}\n`);
+            for (const pattern of patterns) {
+                const severityEmoji = this.getSeverityEmoji(pattern.severity);
+                lines.push(`#### ${severityEmoji} ${pattern.name} (\`${pattern.id}\`)\n`);
+                lines.push(`**Why it's problematic:** ${pattern.explanation}\n`);
+                lines.push(`**What to do instead:** ${pattern.suggestion}\n`);
+            }
+        }
+        return lines.join('\n');
+    }
+    /**
+     * Format conventions section
+     */
+    formatConventions(constraints) {
+        const lines = ['## Conventions\n'];
+        lines.push('These conventions should be followed throughout the codebase for consistency and maintainability.\n');
+        for (const convention of constraints.conventions) {
+            lines.push(`### ${this.formatCategoryName(convention.category)}\n`);
+            lines.push(`${convention.description}\n`);
+            if (convention.examples && convention.examples.length > 0) {
+                lines.push('**Examples:**');
+                for (const example of convention.examples) {
+                    lines.push(`- ${example}`);
+                }
+                lines.push('');
+            }
+        }
+        return lines.join('\n');
+    }
+    /**
+     * Format active suppressions section
+     */
+    formatSuppressions(constraints) {
+        const lines = ['## Active Suppressions\n'];
+        lines.push('These patterns are intentionally suppressed in specific locations. ' +
+            'Do not flag or attempt to fix these.\n');
+        // 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) {
+            lines.push(`### \`${patternId}\`\n`);
+            for (const suppression of suppressions) {
+                lines.push(`- **\`${suppression.file}\`** (${suppression.scope})`);
+                lines.push(`  - Reason: ${suppression.reason}`);
+                if (suppression.expiresAt) {
+                    const expiresDate = new Date(suppression.expiresAt);
+                    const expiresValue = Number.isNaN(expiresDate.getTime())
+                        ? String(suppression.expiresAt)
+                        : expiresDate.toISOString().slice(0, 10);
+                    lines.push(`  - Expires: ${expiresValue}`);
+                }
+                lines.push('');
+            }
+        }
+        return lines.join('\n');
+    }
+    /**
+     * Get emoji for severity level
+     */
+    getSeverityEmoji(severity) {
+        switch (severity) {
+            case 'error':
+                return '🚫';
+            case 'warning':
+                return '⚠️';
+            case 'info':
+                return 'ℹ️';
+            default:
+                return '•';
+        }
+    }
+    /**
+     * 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 llms.txt with default options
+ *
+ * @param constraints - Constraints to format
+ * @returns llms.txt markdown string
+ */
+export function formatAsLlmsTxt(constraints) {
+    const formatter = new LlmsTxtFormatter();
+    return formatter.format(constraints);
+}
+/**
+ * Format constraints as llms.txt without metadata
+ *
+ * @param constraints - Constraints to format
+ * @returns llms.txt markdown string
+ */
+export function formatAsLlmsTxtWithoutMetadata(constraints) {
+    const formatter = new LlmsTxtFormatter({ includeMetadata: false });
+    return formatter.format(constraints);
+}

package/dist/export/formatters/mcp-resource-formatter.d.ts

@@ -0,0 +1,186 @@
+/**
+ * MCP Resource Formatter
+ *
+ * Formats Anvil constraints as Model Context Protocol (MCP) compatible resources.
+ *
+ * MCP is a protocol for exposing contextual information to AI models during generation.
+ * See: https://modelcontextprotocol.io/
+ *
+ * @module export/formatters/mcp-resource-formatter
+ */
+import type { Constraints } from '../constraint-collector.js';
+/**
+ * MCP resource representation of constraints
+ */
+export interface McpResource {
+    /** Resource URI (e.g., anvil://constraints) */
+    uri: string;
+    /** Resource name */
+    name: string;
+    /** Resource description */
+    description: string;
+    /** MIME type */
+    mimeType: string;
+    /** Resource contents */
+    contents: McpResourceContents;
+}
+/**
+ * Contents of an MCP resource
+ */
+export interface McpResourceContents {
+    /** Architecture boundaries */
+    boundaries?: McpBoundary[];
+    /** Layer definitions */
+    layers?: McpLayer[];
+    /** Anti-pattern rules */
+    antiPatterns?: McpAntiPattern[];
+    /** Project conventions */
+    conventions?: McpConvention[];
+    /** Active suppression policies */
+    suppressions?: McpSuppression[];
+    /** Metadata */
+    metadata: {
+        /** When resource was generated */
+        generatedAt: string;
+        /** Workspace root */
+        workspaceRoot: string;
+        /** Whether baseline exists */
+        hasBaseline: boolean;
+        /** Schema version */
+        version: string;
+    };
+}
+/**
+ * MCP representation of a boundary
+ */
+export interface McpBoundary {
+    /** Boundary identifier */
+    id: string;
+    /** Boundary name */
+    name: string;
+    /** Source layer */
+    from: string;
+    /** Target layer */
+    to: string;
+    /** Violation message */
+    message: string;
+    /** Severity level */
+    severity: 'error' | 'warning' | 'info';
+}
+/**
+ * MCP representation of a layer
+ */
+export interface McpLayer {
+    /** Layer name */
+    name: string;
+    /** File patterns */
+    patterns: string[];
+    /** Dependencies */
+    dependsOn: string[];
+    /** Description */
+    description?: string;
+}
+/**
+ * MCP representation of an anti-pattern
+ */
+export interface McpAntiPattern {
+    /** Pattern ID */
+    id: string;
+    /** Pattern name */
+    name: string;
+    /** Pattern category */
+    category: string;
+    /** Why it's problematic */
+    explanation: string;
+    /** What to do instead */
+    suggestion: string;
+    /** Severity level */
+    severity: 'error' | 'warning' | 'info';
+    /** Whether enabled */
+    enabled: boolean;
+}
+/**
+ * MCP representation of a convention
+ */
+export interface McpConvention {
+    /** Convention category */
+    category: string;
+    /** Description */
+    description: string;
+    /** Examples */
+    examples?: string[];
+}
+/**
+ * MCP representation of a suppression
+ */
+export interface McpSuppression {
+    /** Pattern ID being suppressed */
+    patternId: string;
+    /** File path */
+    file: string;
+    /** Suppression scope */
+    scope: string;
+    /** Reason for suppression */
+    reason: string;
+    /** Expiry date */
+    expiresAt?: string;
+}
+/**
+ * Configuration for MCP resource formatting
+ */
+export interface McpResourceFormatterOptions {
+    /** Base URI for resources */
+    baseUri?: string;
+    /** Include boundaries */
+    includeBoundaries?: boolean;
+    /** Include layers */
+    includeLayers?: boolean;
+    /** Include anti-patterns */
+    includeAntiPatterns?: boolean;
+    /** Include conventions */
+    includeConventions?: boolean;
+    /** Include active suppressions */
+    includeSuppressions?: boolean;
+}
+/**
+ * Formats constraints as MCP-compatible resources
+ */
+export declare class McpResourceFormatter {
+    private readonly options;
+    constructor(options?: McpResourceFormatterOptions);
+    /**
+     * Format constraints as MCP resource
+     *
+     * @param constraints - Constraints to format
+     * @returns MCP resource object
+     */
+    format(constraints: Constraints): McpResource;
+    /**
+     * Format constraints as JSON string
+     *
+     * @param constraints - Constraints to format
+     * @param pretty - Whether to pretty-print JSON
+     * @returns JSON string
+     */
+    formatAsJson(constraints: Constraints, pretty?: boolean): string;
+    /**
+     * Format resource contents
+     */
+    private formatContents;
+}
+/**
+ * Format constraints as MCP resource with default options
+ *
+ * @param constraints - Constraints to format
+ * @returns MCP resource object
+ */
+export declare function formatAsMcpResource(constraints: Constraints): McpResource;
+/**
+ * Format constraints as MCP resource JSON
+ *
+ * @param constraints - Constraints to format
+ * @param pretty - Whether to pretty-print JSON
+ * @returns JSON string
+ */
+export declare function formatAsMcpResourceJson(constraints: Constraints, pretty?: boolean): string;
+//# sourceMappingURL=mcp-resource-formatter.d.ts.map

package/dist/export/formatters/mcp-resource-formatter.d.ts.map

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

package/dist/export/formatters/mcp-resource-formatter.js

@@ -0,0 +1,139 @@
+/**
+ * MCP Resource Formatter
+ *
+ * Formats Anvil constraints as Model Context Protocol (MCP) compatible resources.
+ *
+ * MCP is a protocol for exposing contextual information to AI models during generation.
+ * See: https://modelcontextprotocol.io/
+ *
+ * @module export/formatters/mcp-resource-formatter
+ */
+// =============================================================================
+// MCP Resource Formatter
+// =============================================================================
+/**
+ * Formats constraints as MCP-compatible resources
+ */
+export class McpResourceFormatter {
+    options;
+    constructor(options = {}) {
+        this.options = {
+            baseUri: 'anvil://constraints',
+            includeBoundaries: true,
+            includeLayers: true,
+            includeAntiPatterns: true,
+            includeConventions: true,
+            includeSuppressions: true,
+            ...options,
+        };
+    }
+    /**
+     * Format constraints as MCP resource
+     *
+     * @param constraints - Constraints to format
+     * @returns MCP resource object
+     */
+    format(constraints) {
+        return {
+            uri: this.options.baseUri,
+            name: 'Anvil Architecture Constraints',
+            description: 'Architecture rules, anti-patterns, and conventions for this codebase',
+            mimeType: 'application/json',
+            contents: this.formatContents(constraints),
+        };
+    }
+    /**
+     * Format constraints as JSON string
+     *
+     * @param constraints - Constraints to format
+     * @param pretty - Whether to pretty-print JSON
+     * @returns JSON string
+     */
+    formatAsJson(constraints, pretty = true) {
+        const resource = this.format(constraints);
+        return JSON.stringify(resource, null, pretty ? 2 : 0);
+    }
+    /**
+     * Format resource contents
+     */
+    formatContents(constraints) {
+        const contents = {
+            metadata: {
+                generatedAt: new Date().toISOString(),
+                workspaceRoot: constraints.metadata.workspaceRoot,
+                hasBaseline: constraints.metadata.hasBaseline,
+                version: '1.0.0',
+            },
+        };
+        if (this.options.includeBoundaries && constraints.boundaries.length > 0) {
+            contents.boundaries = constraints.boundaries.map((boundary, index) => ({
+                id: `boundary-${index + 1}`,
+                name: boundary.name,
+                from: boundary.from,
+                to: boundary.to,
+                message: boundary.message,
+                severity: boundary.severity,
+            }));
+        }
+        if (this.options.includeLayers && constraints.layers.length > 0) {
+            contents.layers = constraints.layers.map((layer) => ({
+                name: layer.name,
+                patterns: layer.patterns,
+                dependsOn: layer.dependsOn,
+                description: layer.description,
+            }));
+        }
+        if (this.options.includeAntiPatterns && constraints.antiPatterns.length > 0) {
+            contents.antiPatterns = constraints.antiPatterns.map((pattern) => ({
+                id: pattern.id,
+                name: pattern.name,
+                category: pattern.category,
+                explanation: pattern.explanation,
+                suggestion: pattern.suggestion,
+                severity: pattern.severity,
+                enabled: pattern.enabled,
+            }));
+        }
+        if (this.options.includeConventions && constraints.conventions.length > 0) {
+            contents.conventions = constraints.conventions.map((convention) => ({
+                category: convention.category,
+                description: convention.description,
+                examples: convention.examples,
+            }));
+        }
+        if (this.options.includeSuppressions && constraints.suppressions.length > 0) {
+            contents.suppressions = constraints.suppressions.map((suppression) => ({
+                patternId: suppression.patternId,
+                file: suppression.file,
+                scope: suppression.scope,
+                reason: suppression.reason,
+                expiresAt: suppression.expiresAt,
+            }));
+        }
+        return contents;
+    }
+}
+// =============================================================================
+// Convenience Functions
+// =============================================================================
+/**
+ * Format constraints as MCP resource with default options
+ *
+ * @param constraints - Constraints to format
+ * @returns MCP resource object
+ */
+export function formatAsMcpResource(constraints) {
+    const formatter = new McpResourceFormatter();
+    return formatter.format(constraints);
+}
+/**
+ * Format constraints as MCP resource JSON
+ *
+ * @param constraints - Constraints to format
+ * @param pretty - Whether to pretty-print JSON
+ * @returns JSON string
+ */
+export function formatAsMcpResourceJson(constraints, pretty = true) {
+    const formatter = new McpResourceFormatter();
+    return formatter.formatAsJson(constraints, pretty);
+}

package/dist/export/formatters/prompt-formatter.d.ts

@@ -0,0 +1,83 @@
+/**
+ * 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
+ */
+import type { Constraints } from '../constraint-collector.js';
+/**
+ * Configuration for prompt formatting
+ */
+export interface PromptFormatterOptions {
+    /** Include boundaries section */
+    includeBoundaries?: boolean;
+    /** Include layers section */
+    includeLayers?: boolean;
+    /** Include anti-patterns section */
+    includeAntiPatterns?: boolean;
+    /** Include conventions section */
+    includeConventions?: boolean;
+    /** Include active suppressions section */
+    includeSuppressions?: boolean;
+    /** Use concise format (shorter, less detail) */
+    concise?: boolean;
+}
+/**
+ * Formats constraints as system prompt text
+ */
+export declare class PromptFormatter {
+    private readonly options;
+    constructor(options?: PromptFormatterOptions);
+    /**
+     * Format constraints as prompt text
+     *
+     * @param constraints - Constraints to format
+     * @returns System prompt text
+     */
+    format(constraints: Constraints): string;
+    /**
+     * Format opening instruction
+     */
+    private formatOpening;
+    /**
+     * Format architecture boundaries section
+     */
+    private formatBoundaries;
+    /**
+     * Format layer definitions section
+     */
+    private formatLayers;
+    /**
+     * Format anti-patterns section
+     */
+    private formatAntiPatterns;
+    /**
+     * Format conventions section
+     */
+    private formatConventions;
+    /**
+     * Format active suppressions section
+     */
+    private formatSuppressions;
+    /**
+     * Format category name for display
+     */
+    private formatCategoryName;
+}
+/**
+ * Format constraints as prompt fragment with default options
+ *
+ * @param constraints - Constraints to format
+ * @returns Prompt text
+ */
+export declare function formatAsPrompt(constraints: Constraints): string;
+/**
+ * Format constraints as concise prompt fragment
+ *
+ * @param constraints - Constraints to format
+ * @returns Concise prompt text
+ */
+export declare function formatAsConcisePrompt(constraints: Constraints): string;
+//# sourceMappingURL=prompt-formatter.d.ts.map

package/dist/export/formatters/prompt-formatter.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"prompt-formatter.d.ts","sourceRoot":"","sources":["../../../src/export/formatters/prompt-formatter.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AAEH,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,4BAA4B,CAAC;AAM9D;;GAEG;AACH,MAAM,WAAW,sBAAsB;IACrC,iCAAiC;IACjC,iBAAiB,CAAC,EAAE,OAAO,CAAC;IAC5B,6BAA6B;IAC7B,aAAa,CAAC,EAAE,OAAO,CAAC;IACxB,oCAAoC;IACpC,mBAAmB,CAAC,EAAE,OAAO,CAAC;IAC9B,kCAAkC;IAClC,kBAAkB,CAAC,EAAE,OAAO,CAAC;IAC7B,0CAA0C;IAC1C,mBAAmB,CAAC,EAAE,OAAO,CAAC;IAC9B,gDAAgD;IAChD,OAAO,CAAC,EAAE,OAAO,CAAC;CACnB;AAMD;;GAEG;AACH,qBAAa,eAAe;IAC1B,OAAO,CAAC,QAAQ,CAAC,OAAO,CAAmC;gBAE/C,OAAO,GAAE,sBAA2B;IAYhD;;;;;OAKG;IACH,MAAM,CAAC,WAAW,EAAE,WAAW,GAAG,MAAM;IAkCxC;;OAEG;IACH,OAAO,CAAC,aAAa;IAkBrB;;OAEG;IACH,OAAO,CAAC,gBAAgB;IAwBxB;;OAEG;IACH,OAAO,CAAC,YAAY;IAiCpB;;OAEG;IACH,OAAO,CAAC,kBAAkB;IAsC1B;;OAEG;IACH,OAAO,CAAC,iBAAiB;IAwBzB;;OAEG;IACH,OAAO,CAAC,kBAAkB;IA0C1B;;OAEG;IACH,OAAO,CAAC,kBAAkB;CAM3B;AAMD;;;;;GAKG;AACH,wBAAgB,cAAc,CAAC,WAAW,EAAE,WAAW,GAAG,MAAM,CAG/D;AAED;;;;;GAKG;AACH,wBAAgB,qBAAqB,CAAC,WAAW,EAAE,WAAW,GAAG,MAAM,CAGtE"}