@eddacraft/anvil-core 0.1.0

package/dist/architecture/rego-generator.js

@@ -0,0 +1,229 @@
+import { writeFile, mkdir, readFile } from 'node:fs/promises';
+import { existsSync } from 'node:fs';
+import { join, dirname } from 'node:path';
+import { createHash } from 'node:crypto';
+import { createDebugger } from '../utils/debug.js';
+const debug = createDebugger('compiler');
+export const GENERATED_POLICIES_DIR = '.anvil/policies/.generated';
+export const REGO_FILENAME = 'architecture.rego';
+export const REGO_PACKAGE = 'anvil.policies.architecture';
+/**
+ * Get the path to the generated Rego file
+ */
+export function getRegoPath(workspaceRoot) {
+    return join(workspaceRoot, GENERATED_POLICIES_DIR, REGO_FILENAME);
+}
+/**
+ * Check if generated Rego file exists
+ */
+export function regoExists(workspaceRoot) {
+    return existsSync(getRegoPath(workspaceRoot));
+}
+/**
+ * Check if Rego needs regeneration based on definition hash
+ */
+export async function needsRegoRegeneration(workspaceRoot, definition) {
+    const regoPath = getRegoPath(workspaceRoot);
+    if (!existsSync(regoPath)) {
+        return true;
+    }
+    const existingContent = await readFile(regoPath, 'utf-8');
+    const hashMatch = existingContent.match(/# hash: ([a-f0-9]+)/);
+    if (!hashMatch) {
+        return true;
+    }
+    const currentHash = computeDefinitionHash(definition);
+    return hashMatch[1] !== currentHash;
+}
+function computeDefinitionHash(definition) {
+    const content = JSON.stringify(definition);
+    return createHash('sha256').update(content).digest('hex').slice(0, 16);
+}
+/**
+ * Write generated Rego policy file
+ */
+export async function writeRegoPolicy(workspaceRoot, definition) {
+    const regoPath = getRegoPath(workspaceRoot);
+    debug('writing Rego policy', regoPath);
+    const regoDir = dirname(regoPath);
+    if (!existsSync(regoDir)) {
+        await mkdir(regoDir, { recursive: true });
+    }
+    const content = generateRegoPolicy(definition);
+    await writeFile(regoPath, content, 'utf-8');
+    return regoPath;
+}
+/**
+ * Generate Rego policy content from architecture definition
+ */
+export function generateRegoPolicy(definition) {
+    const hash = computeDefinitionHash(definition);
+    const lines = [];
+    // Header
+    lines.push('# Auto-generated by Anvil - do not edit manually');
+    lines.push(`# hash: ${hash}`);
+    lines.push('# Generated from: .anvil/architecture.yaml');
+    lines.push('#');
+    lines.push('# This policy enforces architecture boundaries defined in architecture.yaml.');
+    lines.push('# It uses the architecture context provided by ArchitectureCheck.');
+    lines.push('');
+    lines.push(`package ${REGO_PACKAGE}`);
+    lines.push('');
+    lines.push('import rego.v1');
+    lines.push('');
+    // Generate layer definitions as data
+    lines.push('# Layer definitions from architecture.yaml');
+    lines.push(`layers := ${JSON.stringify(Object.keys(definition.layers))}`);
+    lines.push('');
+    // Generate allowed dependencies map
+    const allowedDeps = {};
+    for (const [layerName, layerDef] of Object.entries(definition.layers)) {
+        allowedDeps[layerName] = layerDef.depends_on;
+    }
+    lines.push('# Allowed dependencies per layer');
+    lines.push(`allowed_deps := ${JSON.stringify(allowedDeps)}`);
+    lines.push('');
+    // Generate options
+    const options = definition.options ?? {
+        detect_circular: true,
+        default_severity: 'error',
+    };
+    lines.push('# Options');
+    lines.push(`detect_circular := ${options.detect_circular ?? true}`);
+    lines.push(`default_severity := "${options.default_severity ?? 'error'}"`);
+    lines.push('');
+    // Helper function to check if a layer can depend on another
+    lines.push('# Check if source layer is allowed to depend on target layer');
+    lines.push('layer_can_depend(source, target) if {');
+    lines.push('  source == target  # Same layer is always allowed');
+    lines.push('}');
+    lines.push('');
+    lines.push('layer_can_depend(source, target) if {');
+    lines.push('  allowed := allowed_deps[source]');
+    lines.push('  target in allowed');
+    lines.push('}');
+    lines.push('');
+    // Violation rule for layer boundary violations
+    lines.push('# Detect layer boundary violations from architecture context');
+    lines.push('violation contains result if {');
+    lines.push('  some v in input.architecture.violations');
+    lines.push('  v.from_layer != null');
+    lines.push('  v.to_layer != null');
+    lines.push('  not layer_can_depend(v.from_layer, v.to_layer)');
+    lines.push('  v.is_new');
+    lines.push('  result := {');
+    lines.push('    "rule": "layer-boundary",');
+    lines.push('    "severity": v.severity,');
+    lines.push('    "message": sprintf("%s (%s) cannot depend on %s (%s)", [v.from, v.from_layer, v.to, v.to_layer]),');
+    lines.push('    "path": v.from,');
+    lines.push('    "category": "architecture",');
+    lines.push('  }');
+    lines.push('}');
+    lines.push('');
+    // Violation rule for circular dependencies
+    lines.push('# Detect circular dependencies');
+    lines.push('violation contains result if {');
+    lines.push('  detect_circular');
+    lines.push('  some v in input.architecture.violations');
+    lines.push('  v.is_circular');
+    lines.push('  v.is_new');
+    lines.push('  result := {');
+    lines.push('    "rule": "no-circular",');
+    lines.push('    "severity": default_severity,');
+    lines.push('    "message": sprintf("Circular dependency: %s -> %s", [v.from, v.to]),');
+    lines.push('    "path": v.from,');
+    lines.push('    "category": "architecture",');
+    lines.push('  }');
+    lines.push('}');
+    lines.push('');
+    // Violation rule for new violations (not in baseline)
+    lines.push('# Flag new violations (not in baseline)');
+    lines.push('violation contains result if {');
+    lines.push('  some v in input.architecture.violations');
+    lines.push('  v.is_new');
+    lines.push('  result := {');
+    lines.push('    "rule": "new-violation",');
+    lines.push('    "severity": "warning",');
+    lines.push('    "message": sprintf("New architecture violation: %s -> %s (%s)", [v.from, v.to, v.rule]),');
+    lines.push('    "path": v.from,');
+    lines.push('    "category": "architecture",');
+    lines.push('  }');
+    lines.push('}');
+    lines.push('');
+    // Generate explicit rules from definition
+    if (definition.rules.length > 0) {
+        lines.push('# Explicit rules from architecture.yaml');
+        for (const rule of definition.rules) {
+            if (!rule.allowed) {
+                // This is a forbidden dependency rule
+                const fromLayer = definition.layers[rule.from];
+                const toLayer = definition.layers[rule.to];
+                if (fromLayer && toLayer) {
+                    const ruleName = sanitiseRuleName(rule.name);
+                    lines.push(`# Rule: ${rule.name}`);
+                    lines.push(`violation contains result if {`);
+                    lines.push(`  some v in input.architecture.violations`);
+                    lines.push(`  v.from_layer == "${rule.from}"`);
+                    lines.push(`  v.to_layer == "${rule.to}"`);
+                    lines.push(`  v.is_new`);
+                    lines.push(`  result := {`);
+                    lines.push(`    "rule": "${ruleName}",`);
+                    lines.push(`    "severity": "${rule.severity}",`);
+                    lines.push(`    "message": "${escapeString(rule.message || `${rule.from} must not depend on ${rule.to}`)}",`);
+                    lines.push(`    "path": v.from,`);
+                    lines.push(`    "category": "architecture",`);
+                    lines.push(`  }`);
+                    lines.push(`}`);
+                    lines.push('');
+                }
+            }
+        }
+    }
+    // Summary helper for external use
+    lines.push('# Summary of architecture health');
+    lines.push('summary := {');
+    lines.push('  "total_violations": count(violation),');
+    lines.push('  "layer_violations": count([v | some v in violation; v.rule == "layer-boundary"]),');
+    lines.push('  "circular_violations": count([v | some v in violation; v.rule == "no-circular"]),');
+    lines.push('  "new_violations": count([v | some v in violation; v.rule == "new-violation"]),');
+    lines.push('}');
+    lines.push('');
+    // Deny rule for blocking on errors
+    lines.push('# Deny if any error-level violations exist');
+    lines.push('deny contains msg if {');
+    lines.push('  some v in violation');
+    lines.push('  v.severity == "error"');
+    lines.push('  msg := v.message');
+    lines.push('}');
+    lines.push('');
+    // Warn rule for warning-level violations
+    lines.push('# Warn for warning-level violations');
+    lines.push('warn contains msg if {');
+    lines.push('  some v in violation');
+    lines.push('  v.severity == "warn"');
+    lines.push('  msg := v.message');
+    lines.push('}');
+    lines.push('');
+    lines.push('warn contains msg if {');
+    lines.push('  some v in violation');
+    lines.push('  v.severity == "warning"');
+    lines.push('  msg := v.message');
+    lines.push('}');
+    lines.push('');
+    return lines.join('\n');
+}
+/**
+ * Sanitise rule name for use in Rego
+ */
+function sanitiseRuleName(name) {
+    return name
+        .toLowerCase()
+        .replace(/[^a-z0-9]+/g, '-')
+        .replace(/^-|-$/g, '');
+}
+/**
+ * Escape string for Rego string literal
+ */
+function escapeString(str) {
+    return str.replace(/\\/g, '\\\\').replace(/"/g, '\\"').replace(/\n/g, '\\n');
+}

package/dist/architecture/templates/index.d.ts

@@ -0,0 +1,39 @@
+import { z } from 'zod';
+import type { ArchitectureTemplate, LayerDefinition } from '../definition-schema.js';
+declare const TemplateFileSchema: z.ZodObject<{
+    name: z.ZodString;
+    description: z.ZodString;
+    layers: z.ZodRecord<z.ZodString, z.ZodObject<{
+        patterns: z.ZodArray<z.ZodString>;
+        depends_on: z.ZodDefault<z.ZodArray<z.ZodString>>;
+        description: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>>;
+}, z.core.$strip>;
+export type TemplateFile = z.infer<typeof TemplateFileSchema>;
+export interface LoadedTemplate {
+    name: ArchitectureTemplate;
+    description: string;
+    layers: Record<string, LayerDefinition>;
+}
+export declare class TemplateLoader {
+    private cache;
+    private templatesDir;
+    constructor(templatesDir?: string);
+    list(): Promise<ArchitectureTemplate[]>;
+    get(name: ArchitectureTemplate): Promise<LoadedTemplate>;
+    validate(name: ArchitectureTemplate): Promise<{
+        valid: boolean;
+        errors: string[];
+    }>;
+    getAll(): Promise<LoadedTemplate[]>;
+    clearCache(): void;
+}
+export declare function getTemplateLoader(): TemplateLoader;
+export declare function listTemplates(): Promise<ArchitectureTemplate[]>;
+export declare function getTemplate(name: ArchitectureTemplate): Promise<LoadedTemplate>;
+export declare function validateTemplate(name: ArchitectureTemplate): Promise<{
+    valid: boolean;
+    errors: string[];
+}>;
+export {};
+//# sourceMappingURL=index.d.ts.map

package/dist/architecture/templates/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/architecture/templates/index.ts"],"names":[],"mappings":"AAIA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AACxB,OAAO,KAAK,EAAE,oBAAoB,EAAE,eAAe,EAAE,MAAM,yBAAyB,CAAC;AAWrF,QAAA,MAAM,kBAAkB;;;;;;;;iBAItB,CAAC;AAEH,MAAM,MAAM,YAAY,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,kBAAkB,CAAC,CAAC;AAE9D,MAAM,WAAW,cAAc;IAC7B,IAAI,EAAE,oBAAoB,CAAC;IAC3B,WAAW,EAAE,MAAM,CAAC;IACpB,MAAM,EAAE,MAAM,CAAC,MAAM,EAAE,eAAe,CAAC,CAAC;CACzC;AAaD,qBAAa,cAAc;IACzB,OAAO,CAAC,KAAK,CAA0C;IACvD,OAAO,CAAC,YAAY,CAAS;gBAEjB,YAAY,CAAC,EAAE,MAAM;IAI3B,IAAI,IAAI,OAAO,CAAC,oBAAoB,EAAE,CAAC;IAcvC,GAAG,CAAC,IAAI,EAAE,oBAAoB,GAAG,OAAO,CAAC,cAAc,CAAC;IAsCxD,QAAQ,CAAC,IAAI,EAAE,oBAAoB,GAAG,OAAO,CAAC;QAAE,KAAK,EAAE,OAAO,CAAC;QAAC,MAAM,EAAE,MAAM,EAAE,CAAA;KAAE,CAAC;IA0BnF,MAAM,IAAI,OAAO,CAAC,cAAc,EAAE,CAAC;IAKzC,UAAU,IAAI,IAAI;CAGnB;AAID,wBAAgB,iBAAiB,IAAI,cAAc,CAKlD;AAED,wBAAsB,aAAa,IAAI,OAAO,CAAC,oBAAoB,EAAE,CAAC,CAErE;AAED,wBAAsB,WAAW,CAAC,IAAI,EAAE,oBAAoB,GAAG,OAAO,CAAC,cAAc,CAAC,CAErF;AAED,wBAAsB,gBAAgB,CACpC,IAAI,EAAE,oBAAoB,GACzB,OAAO,CAAC;IAAE,KAAK,EAAE,OAAO,CAAC;IAAC,MAAM,EAAE,MAAM,EAAE,CAAA;CAAE,CAAC,CAE/C"}

package/dist/architecture/templates/index.js

@@ -0,0 +1,124 @@
+import { readFile } from 'node:fs/promises';
+import { join, dirname } from 'node:path';
+import { fileURLToPath } from 'node:url';
+import YAML from 'yaml';
+import { z } from 'zod';
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = dirname(__filename);
+const TemplateLayerSchema = z.object({
+    patterns: z.array(z.string()),
+    depends_on: z.array(z.string()).default([]),
+    description: z.string().optional(),
+});
+const TemplateFileSchema = z.object({
+    name: z.string(),
+    description: z.string(),
+    layers: z.record(z.string(), TemplateLayerSchema),
+});
+const TEMPLATE_FILES = {
+    starter: 'starter.yaml',
+    layered: 'layered.yaml',
+    hexagonal: 'hexagonal.yaml',
+    clean: 'clean.yaml',
+    ddd: 'ddd.yaml',
+    monorepo: 'monorepo.yaml',
+    serverless: 'serverless.yaml',
+    'nx-workspace': 'nx-workspace.yaml',
+};
+export class TemplateLoader {
+    cache = new Map();
+    templatesDir;
+    constructor(templatesDir) {
+        this.templatesDir = templatesDir ?? __dirname;
+    }
+    async list() {
+        return [
+            'starter',
+            'layered',
+            'hexagonal',
+            'clean',
+            'ddd',
+            'monorepo',
+            'serverless',
+            'nx-workspace',
+            'custom',
+        ];
+    }
+    async get(name) {
+        if (name === 'custom') {
+            return {
+                name: 'custom',
+                description: 'Empty template for custom architecture definitions',
+                layers: {},
+            };
+        }
+        const cached = this.cache.get(name);
+        if (cached) {
+            return cached;
+        }
+        const filename = TEMPLATE_FILES[name];
+        if (!filename) {
+            throw new Error(`Unknown template: ${name}`);
+        }
+        const filePath = join(this.templatesDir, filename);
+        const content = await readFile(filePath, 'utf-8');
+        const parsed = YAML.parse(content);
+        const validated = TemplateFileSchema.safeParse(parsed);
+        if (!validated.success) {
+            throw new Error(`Invalid template file ${filename}: ${validated.error.message}`);
+        }
+        const template = {
+            name,
+            description: validated.data.description,
+            layers: validated.data.layers,
+        };
+        this.cache.set(name, template);
+        return template;
+    }
+    async validate(name) {
+        try {
+            const template = await this.get(name);
+            const errors = [];
+            for (const [layerName, layer] of Object.entries(template.layers)) {
+                for (const dep of layer.depends_on) {
+                    if (!template.layers[dep]) {
+                        errors.push(`Layer "${layerName}" depends on unknown layer "${dep}"`);
+                    }
+                }
+                if (layer.patterns.length === 0) {
+                    errors.push(`Layer "${layerName}" has no patterns defined`);
+                }
+            }
+            return { valid: errors.length === 0, errors };
+        }
+        catch (err) {
+            return {
+                valid: false,
+                errors: [err instanceof Error ? err.message : 'Unknown error'],
+            };
+        }
+    }
+    async getAll() {
+        const names = await this.list();
+        return Promise.all(names.map((name) => this.get(name)));
+    }
+    clearCache() {
+        this.cache.clear();
+    }
+}
+let defaultLoader = null;
+export function getTemplateLoader() {
+    if (!defaultLoader) {
+        defaultLoader = new TemplateLoader();
+    }
+    return defaultLoader;
+}
+export async function listTemplates() {
+    return getTemplateLoader().list();
+}
+export async function getTemplate(name) {
+    return getTemplateLoader().get(name);
+}
+export async function validateTemplate(name) {
+    return getTemplateLoader().validate(name);
+}

package/dist/architecture/types.d.ts

@@ -0,0 +1,280 @@
+/**
+ * Architecture baseline types
+ *
+ * Defines the schema for .anvil/architecture.json - the architecture baseline
+ * that enables NEW vs existing violation detection.
+ */
+import { z } from 'zod';
+/**
+ * Entry point types detected in the codebase
+ */
+export declare const EntryPointTypeSchema: z.ZodEnum<{
+    unknown: "unknown";
+    cli: "cli";
+    api: "api";
+    test: "test";
+    package: "package";
+    application: "application";
+    http: "http";
+    worker: "worker";
+}>;
+export type EntryPointType = z.infer<typeof EntryPointTypeSchema>;
+/**
+ * Confidence level for detection
+ */
+export declare const DetectionConfidenceSchema: z.ZodEnum<{
+    high: "high";
+    medium: "medium";
+    low: "low";
+}>;
+export type DetectionConfidence = z.infer<typeof DetectionConfidenceSchema>;
+/**
+ * A detected entry point in the codebase
+ */
+export declare const EntryPointSchema: z.ZodObject<{
+    path: z.ZodString;
+    type: z.ZodEnum<{
+        unknown: "unknown";
+        cli: "cli";
+        api: "api";
+        test: "test";
+        package: "package";
+        application: "application";
+        http: "http";
+        worker: "worker";
+    }>;
+    confidence: z.ZodEnum<{
+        high: "high";
+        medium: "medium";
+        low: "low";
+    }>;
+    exports: z.ZodOptional<z.ZodArray<z.ZodString>>;
+}, z.core.$strip>;
+export type EntryPoint = z.infer<typeof EntryPointSchema>;
+/**
+ * Standard layer names (can be extended)
+ */
+export declare const StandardLayerSchema: z.ZodEnum<{
+    application: "application";
+    presentation: "presentation";
+    domain: "domain";
+    infrastructure: "infrastructure";
+    shared: "shared";
+}>;
+export type StandardLayer = z.infer<typeof StandardLayerSchema>;
+/**
+ * Layer definition with dependency rules
+ */
+export declare const LayerSchema: z.ZodObject<{
+    patterns: z.ZodArray<z.ZodString>;
+    depends_on: z.ZodArray<z.ZodString>;
+    description: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+export type Layer = z.infer<typeof LayerSchema>;
+/**
+ * Map of layer name to layer definition
+ */
+export declare const LayersSchema: z.ZodRecord<z.ZodString, z.ZodObject<{
+    patterns: z.ZodArray<z.ZodString>;
+    depends_on: z.ZodArray<z.ZodString>;
+    description: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>>;
+export type Layers = z.infer<typeof LayersSchema>;
+/**
+ * Explicit boundary rule
+ */
+export declare const BoundarySchema: z.ZodObject<{
+    name: z.ZodString;
+    from: z.ZodString;
+    to: z.ZodString;
+    severity: z.ZodEnum<{
+        warning: "warning";
+        error: "error";
+        info: "info";
+    }>;
+    message: z.ZodString;
+    confidence: z.ZodOptional<z.ZodEnum<{
+        high: "high";
+        medium: "medium";
+        low: "low";
+    }>>;
+}, z.core.$strip>;
+export type Boundary = z.infer<typeof BoundarySchema>;
+/**
+ * A recorded violation in the baseline
+ */
+export declare const BaselineViolationSchema: z.ZodObject<{
+    id: z.ZodString;
+    from_layer: z.ZodString;
+    to_layer: z.ZodString;
+    from_file: z.ZodString;
+    to_file: z.ZodString;
+    import_line: z.ZodNumber;
+    rule: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+export type BaselineViolation = z.infer<typeof BaselineViolationSchema>;
+/**
+ * Snapshot of the architecture state at baseline time
+ */
+export declare const BaselineSnapshotSchema: z.ZodObject<{
+    module_count: z.ZodNumber;
+    timestamp: z.ZodString;
+    violations: z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        from_layer: z.ZodString;
+        to_layer: z.ZodString;
+        from_file: z.ZodString;
+        to_file: z.ZodString;
+        import_line: z.ZodNumber;
+        rule: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>>;
+}, z.core.$strip>;
+export type BaselineSnapshot = z.infer<typeof BaselineSnapshotSchema>;
+/**
+ * Complete architecture baseline stored in .anvil/architecture.json
+ */
+export declare const ArchitectureBaselineSchema: z.ZodObject<{
+    schema_version: z.ZodLiteral<"0.1.0">;
+    created_at: z.ZodString;
+    updated_at: z.ZodString;
+    entry_points: z.ZodArray<z.ZodObject<{
+        path: z.ZodString;
+        type: z.ZodEnum<{
+            unknown: "unknown";
+            cli: "cli";
+            api: "api";
+            test: "test";
+            package: "package";
+            application: "application";
+            http: "http";
+            worker: "worker";
+        }>;
+        confidence: z.ZodEnum<{
+            high: "high";
+            medium: "medium";
+            low: "low";
+        }>;
+        exports: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    }, z.core.$strip>>;
+    layers: z.ZodRecord<z.ZodString, z.ZodObject<{
+        patterns: z.ZodArray<z.ZodString>;
+        depends_on: z.ZodArray<z.ZodString>;
+        description: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>>;
+    boundaries: z.ZodArray<z.ZodObject<{
+        name: z.ZodString;
+        from: z.ZodString;
+        to: z.ZodString;
+        severity: z.ZodEnum<{
+            warning: "warning";
+            error: "error";
+            info: "info";
+        }>;
+        message: z.ZodString;
+        confidence: z.ZodOptional<z.ZodEnum<{
+            high: "high";
+            medium: "medium";
+            low: "low";
+        }>>;
+    }, z.core.$strip>>;
+    baseline_snapshot: z.ZodObject<{
+        module_count: z.ZodNumber;
+        timestamp: z.ZodString;
+        violations: z.ZodArray<z.ZodObject<{
+            id: z.ZodString;
+            from_layer: z.ZodString;
+            to_layer: z.ZodString;
+            from_file: z.ZodString;
+            to_file: z.ZodString;
+            import_line: z.ZodNumber;
+            rule: z.ZodOptional<z.ZodString>;
+        }, z.core.$strip>>;
+    }, z.core.$strip>;
+}, z.core.$strip>;
+export type ArchitectureBaseline = z.infer<typeof ArchitectureBaselineSchema>;
+/**
+ * Result of layer detection for a file
+ */
+export declare const LayerAssignmentSchema: z.ZodObject<{
+    file: z.ZodString;
+    layer: z.ZodNullable<z.ZodString>;
+    confidence: z.ZodEnum<{
+        high: "high";
+        medium: "medium";
+        low: "low";
+    }>;
+    matched_pattern: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+export type LayerAssignment = z.infer<typeof LayerAssignmentSchema>;
+/**
+ * A dependency edge between two files
+ */
+export declare const DependencyEdgeSchema: z.ZodObject<{
+    from: z.ZodString;
+    to: z.ZodString;
+    from_layer: z.ZodNullable<z.ZodString>;
+    to_layer: z.ZodNullable<z.ZodString>;
+    line: z.ZodNumber;
+    type: z.ZodEnum<{
+        import: "import";
+        require: "require";
+        dynamic: "dynamic";
+    }>;
+}, z.core.$strip>;
+export type DependencyEdge = z.infer<typeof DependencyEdgeSchema>;
+/**
+ * A detected boundary violation
+ */
+export declare const BoundaryViolationSchema: z.ZodObject<{
+    edge: z.ZodObject<{
+        from: z.ZodString;
+        to: z.ZodString;
+        from_layer: z.ZodNullable<z.ZodString>;
+        to_layer: z.ZodNullable<z.ZodString>;
+        line: z.ZodNumber;
+        type: z.ZodEnum<{
+            import: "import";
+            require: "require";
+            dynamic: "dynamic";
+        }>;
+    }, z.core.$strip>;
+    boundary: z.ZodOptional<z.ZodObject<{
+        name: z.ZodString;
+        from: z.ZodString;
+        to: z.ZodString;
+        severity: z.ZodEnum<{
+            warning: "warning";
+            error: "error";
+            info: "info";
+        }>;
+        message: z.ZodString;
+        confidence: z.ZodOptional<z.ZodEnum<{
+            high: "high";
+            medium: "medium";
+            low: "low";
+        }>>;
+    }, z.core.$strip>>;
+    is_new: z.ZodBoolean;
+    baseline_id: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+export type BoundaryViolation = z.infer<typeof BoundaryViolationSchema>;
+/**
+ * Create a violation ID from edge details
+ */
+export declare function createViolationId(fromFile: string, toFile: string, line: number): string;
+/**
+ * Check if a violation exists in the baseline
+ */
+export declare function isExistingViolation(violation: BoundaryViolation, baseline: BaselineSnapshot): boolean;
+/**
+ * Create default layer structure for common patterns.
+ *
+ * Patterns use **\/ prefix to match files in any directory structure,
+ * supporting both single-app (src/) and monorepo (packages/star/src/) layouts.
+ */
+export declare function createDefaultLayers(): Layers;
+/**
+ * Create default boundaries from layer structure
+ */
+export declare function createDefaultBoundaries(layers: Layers): Boundary[];
+//# sourceMappingURL=types.d.ts.map

package/dist/architecture/types.d.ts.map

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