@eddacraft/anvil-core 0.1.0

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

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

package/dist/architecture/index.js

@@ -0,0 +1,48 @@
+/**
+ * Architecture analysis module
+ *
+ * Provides architecture baseline management, layer detection,
+ * entry point detection, and boundary violation analysis.
+ */
+// Types
+export { 
+// Entry points
+EntryPointTypeSchema, DetectionConfidenceSchema, EntryPointSchema, 
+// Layers
+StandardLayerSchema, LayerSchema, LayersSchema, 
+// Boundaries
+BoundarySchema, 
+// Violations
+BaselineViolationSchema, 
+// Baseline
+BaselineSnapshotSchema, ArchitectureBaselineSchema, 
+// Analysis results
+LayerAssignmentSchema, DependencyEdgeSchema, BoundaryViolationSchema, 
+// Utilities
+createViolationId, isExistingViolation, createDefaultLayers, createDefaultBoundaries, } from './types.js';
+// Layer detection
+export { LayerDetector, createLayerDetector } from './layer-detector.js';
+// Entry point detection
+export { EntryPointDetector, createEntryPointDetector } from './entry-detector.js';
+// Baseline management
+export { BASELINE_FILENAME, ANVIL_DIR, getBaselinePath, baselineExists, loadBaseline, saveBaseline, createBaseline, updateBaseline, mergeViolations, findNewViolations, findFixedViolations, BaselineManager, createBaselineManager, } from './baseline.js';
+// Architecture analyzer
+export { ArchitectureAnalyzer, createArchitectureAnalyzer, analyseArchitecture, inferBaseline, } from './analyzer.js';
+// HTML/CSS edge detection
+export { extractHtmlEdges, extractCssEdges } from './edge-detector-web.js';
+// Edge detection
+export { createEdgeFingerprint, fingerprintEdge, resolveImportPath, extractImports, extractImportsFromFiles, compareToBaseline, toDependencyEdge, deduplicateEdges, filterCrossLayerEdges, } from './edge-detector.js';
+// Architecture definition schema
+export { ArchitectureTemplateSchema, LayerDefinitionSchema, BoundedContextSchema, RuleSeveritySchema, ArchitectureRuleSchema, ArchitectureOptionsSchema, ArchitectureDefinitionSchema, AVAILABLE_TEMPLATES, getAvailableTemplates, isValidTemplate, ARCHITECTURE_DEFINITION_VERSION, validateArchitectureDefinition, getDefaultOptions, } from './definition-schema.js';
+// YAML parser
+export { ARCHITECTURE_YAML_FILENAME, getArchitectureYamlPath, architectureYamlExists, parseArchitectureDefinition, writeArchitectureYaml, getTemplateDefaults, mergeWithTemplate, createDefinitionFromTemplate, } from './yaml-parser.js';
+// DC config generator
+export { DC_CONFIG_FILENAME, getDCConfigPath, dcConfigExists, needsRegeneration, writeDCConfig, generateDCConfig, } from './dc-generator.js';
+// Rego policy generator
+export { GENERATED_POLICIES_DIR, REGO_FILENAME, REGO_PACKAGE, getRegoPath, regoExists, needsRegoRegeneration, writeRegoPolicy, generateRegoPolicy, } from './rego-generator.js';
+// Architecture compiler (DC + Rego orchestration)
+export { compileArchitecture, needsCompilation, } from './compiler.js';
+// Template loader
+export { TemplateLoader, getTemplateLoader, listTemplates, getTemplate as getArchitectureTemplate, validateTemplate, } from './templates/index.js';
+// Architecture context (for OPA)
+export { ArchViolationSeveritySchema, ArchViolationSchema, ModuleInfoSchema, LayerStatsSchema, ArchitectureContextSchema, createEmptyContext, ArchitectureContextBuilder, createContextBuilder, } from './context.js';

package/dist/architecture/layer-detector.d.ts

@@ -0,0 +1,60 @@
+/**
+ * Layer detection heuristics
+ *
+ * Detects architectural layers from directory structure and file patterns.
+ * Supports both single-app and monorepo project structures.
+ */
+import type { Layers, LayerAssignment } from './types.js';
+/**
+ * Layer detector using directory heuristics
+ */
+export declare class LayerDetector {
+    private patterns;
+    private customLayers;
+    constructor(customLayers?: Layers);
+    /**
+     * Convert Layers config to LayerPattern array
+     */
+    private layersToPatterns;
+    /**
+     * Detect layer for a single file
+     *
+     * Uses position-aware matching to handle monorepo structures where package names
+     * may match layer patterns (e.g., packages/api/src/services/user.ts should match
+     * 'services', not 'api').
+     */
+    detectLayer(filePath: string): LayerAssignment;
+    /**
+     * Detect layers for multiple files
+     */
+    detectLayers(filePaths: string[]): LayerAssignment[];
+    /**
+     * Get all detected layers from a set of files
+     */
+    getDetectedLayers(filePaths: string[]): Set<string>;
+    /**
+     * Suggest layer structure based on detected patterns
+     */
+    suggestLayers(filePaths: string[]): Layers;
+    /**
+     * Get default dependencies for a layer
+     */
+    private getDefaultDependencies;
+    /**
+     * Get description for a layer
+     */
+    private getLayerDescription;
+    /**
+     * Check if a dependency from one layer to another is allowed
+     */
+    isAllowedDependency(fromLayer: string, toLayer: string, layers?: Layers): boolean;
+    /**
+     * Find files with ambiguous layer assignments
+     */
+    findAmbiguousAssignments(filePaths: string[]): LayerAssignment[];
+}
+/**
+ * Create a layer detector with default patterns
+ */
+export declare function createLayerDetector(customLayers?: Layers): LayerDetector;
+//# sourceMappingURL=layer-detector.d.ts.map

package/dist/architecture/layer-detector.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"layer-detector.d.ts","sourceRoot":"","sources":["../../src/architecture/layer-detector.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAGH,OAAO,KAAK,EAAE,MAAM,EAAE,eAAe,EAAuB,MAAM,YAAY,CAAC;AAoJ/E;;GAEG;AACH,qBAAa,aAAa;IACxB,OAAO,CAAC,QAAQ,CAAiB;IACjC,OAAO,CAAC,YAAY,CAAuB;gBAE/B,YAAY,CAAC,EAAE,MAAM;IAWjC;;OAEG;IACH,OAAO,CAAC,gBAAgB;IAexB;;;;;;OAMG;IACH,WAAW,CAAC,QAAQ,EAAE,MAAM,GAAG,eAAe;IAiF9C;;OAEG;IACH,YAAY,CAAC,SAAS,EAAE,MAAM,EAAE,GAAG,eAAe,EAAE;IAIpD;;OAEG;IACH,iBAAiB,CAAC,SAAS,EAAE,MAAM,EAAE,GAAG,GAAG,CAAC,MAAM,CAAC;IAanD;;OAEG;IACH,aAAa,CAAC,SAAS,EAAE,MAAM,EAAE,GAAG,MAAM;IAkB1C;;OAEG;IACH,OAAO,CAAC,sBAAsB;IAY9B;;OAEG;IACH,OAAO,CAAC,mBAAmB;IAY3B;;OAEG;IACH,mBAAmB,CAAC,SAAS,EAAE,MAAM,EAAE,OAAO,EAAE,MAAM,EAAE,MAAM,CAAC,EAAE,MAAM,GAAG,OAAO;IAiBjF;;OAEG;IACH,wBAAwB,CAAC,SAAS,EAAE,MAAM,EAAE,GAAG,eAAe,EAAE;CAKjE;AAED;;GAEG;AACH,wBAAgB,mBAAmB,CAAC,YAAY,CAAC,EAAE,MAAM,GAAG,aAAa,CAExE"}

package/dist/architecture/layer-detector.js

@@ -0,0 +1,331 @@
+/**
+ * Layer detection heuristics
+ *
+ * Detects architectural layers from directory structure and file patterns.
+ * Supports both single-app and monorepo project structures.
+ */
+import { minimatch } from 'minimatch';
+import { createDebugger } from '../utils/debug.js';
+const debug = createDebugger('architecture');
+/**
+ * Common source root directories that indicate where the actual source code starts
+ */
+const SOURCE_ROOT_PATTERNS = ['src', 'lib', 'source', 'app'];
+/**
+ * Default layer patterns with priorities
+ * Priority determines which layer wins when patterns overlap
+ */
+const DEFAULT_LAYER_PATTERNS = [
+    {
+        layer: 'presentation',
+        patterns: [
+            '**/controllers/**',
+            '**/routes/**',
+            '**/api/**',
+            '**/handlers/**',
+            '**/endpoints/**',
+            '**/views/**',
+            '**/pages/**',
+        ],
+        priority: 1,
+    },
+    {
+        layer: 'application',
+        patterns: [
+            '**/services/**',
+            '**/use-cases/**',
+            '**/usecases/**',
+            '**/application/**',
+            '**/interactors/**',
+        ],
+        priority: 2,
+    },
+    {
+        layer: 'domain',
+        patterns: ['**/domain/**', '**/entities/**', '**/models/**', '**/core/**', '**/business/**'],
+        priority: 3,
+    },
+    {
+        layer: 'infrastructure',
+        patterns: [
+            '**/repositories/**',
+            '**/data/**',
+            '**/infrastructure/**',
+            '**/db/**',
+            '**/database/**',
+            '**/adapters/**',
+            '**/external/**',
+            '**/clients/**',
+        ],
+        priority: 4,
+    },
+    {
+        layer: 'shared',
+        patterns: [
+            '**/utils/**',
+            '**/lib/**',
+            '**/common/**',
+            '**/shared/**',
+            '**/helpers/**',
+            '**/types/**',
+            '**/constants/**',
+            '**/config/**',
+        ],
+        priority: 5,
+    },
+];
+/**
+ * Extract the directory name that a pattern would match
+ * e.g., "**\/controllers\/**" -> "controllers"
+ */
+function getPatternDirectoryName(pattern) {
+    // Match patterns like "**/controllers/**" or "src/controllers/**"
+    const match = pattern.match(/\*\*\/([^/*]+)\/\*\*/);
+    if (match) {
+        return match[1];
+    }
+    // Match patterns like "controllers/**"
+    const simpleMatch = pattern.match(/^([^/*]+)\/\*\*/);
+    if (simpleMatch) {
+        return simpleMatch[1];
+    }
+    return null;
+}
+/**
+ * Find the position of a directory in a path (index from end, 0-based)
+ * Returns -1 if not found
+ *
+ * For "packages/web/src/controllers/user.ts" and "controllers":
+ * - parts = ["packages", "web", "src", "controllers", "user.ts"]
+ * - "controllers" is at index 3, length is 5
+ * - position from end = 5 - 3 - 1 = 1 (1 directory from the file)
+ */
+function getDirectoryPositionFromEnd(filePath, dirName) {
+    const parts = filePath.split('/');
+    const dirIndex = parts.findIndex((part) => part === dirName);
+    if (dirIndex === -1)
+        return -1;
+    return parts.length - dirIndex - 1;
+}
+/**
+ * Find the source root position in a path
+ * Returns the index of the first source root directory (src, lib, etc.)
+ * Returns -1 if no source root is found
+ */
+function findSourceRootIndex(filePath) {
+    const parts = filePath.split('/');
+    for (let i = 0; i < parts.length; i++) {
+        if (SOURCE_ROOT_PATTERNS.includes(parts[i])) {
+            return i;
+        }
+    }
+    return -1;
+}
+/**
+ * Check if a directory name is likely a package/app name rather than a layer directory
+ * by checking if it appears before the source root
+ */
+function isBeforeSourceRoot(filePath, dirName) {
+    const parts = filePath.split('/');
+    const dirIndex = parts.findIndex((part) => part === dirName);
+    const sourceRootIndex = findSourceRootIndex(filePath);
+    // If no source root found, can't determine
+    if (sourceRootIndex === -1)
+        return false;
+    // If the directory appears before the source root, it's likely a package name
+    return dirIndex < sourceRootIndex;
+}
+/**
+ * Layer detector using directory heuristics
+ */
+export class LayerDetector {
+    patterns;
+    customLayers = null;
+    constructor(customLayers) {
+        if (customLayers) {
+            this.customLayers = customLayers;
+            this.patterns = this.layersToPatterns(customLayers);
+            debug('LayerDetector created with custom layers', Object.keys(customLayers));
+        }
+        else {
+            this.patterns = DEFAULT_LAYER_PATTERNS;
+            debug('LayerDetector created with default patterns');
+        }
+    }
+    /**
+     * Convert Layers config to LayerPattern array
+     */
+    layersToPatterns(layers) {
+        const result = [];
+        let priority = 1;
+        for (const [name, layer] of Object.entries(layers)) {
+            result.push({
+                layer: name,
+                patterns: layer.patterns,
+                priority: priority++,
+            });
+        }
+        return result;
+    }
+    /**
+     * Detect layer for a single file
+     *
+     * Uses position-aware matching to handle monorepo structures where package names
+     * may match layer patterns (e.g., packages/api/src/services/user.ts should match
+     * 'services', not 'api').
+     */
+    detectLayer(filePath) {
+        const matches = [];
+        // Normalise path separators
+        const normalisedPath = filePath.replace(/\\/g, '/');
+        for (const layerPattern of this.patterns) {
+            for (const pattern of layerPattern.patterns) {
+                if (minimatch(normalisedPath, pattern, { matchBase: true })) {
+                    const dirName = getPatternDirectoryName(pattern);
+                    const positionScore = dirName
+                        ? getDirectoryPositionFromEnd(normalisedPath, dirName)
+                        : 999;
+                    const beforeSrcRoot = dirName ? isBeforeSourceRoot(normalisedPath, dirName) : false;
+                    matches.push({
+                        layer: layerPattern.layer,
+                        pattern,
+                        priority: layerPattern.priority,
+                        positionScore,
+                        isBeforeSrcRoot: beforeSrcRoot,
+                    });
+                }
+            }
+        }
+        if (matches.length === 0) {
+            return {
+                file: filePath,
+                layer: null,
+                confidence: 'low',
+            };
+        }
+        // Filter out matches that are before the source root (likely package names)
+        // unless ALL matches are before the source root
+        const afterSrcRootMatches = matches.filter((m) => !m.isBeforeSrcRoot);
+        const effectiveMatches = afterSrcRootMatches.length > 0 ? afterSrcRootMatches : matches;
+        // Sort matches by:
+        // 1. Position score (closer to file = better, i.e., lower score)
+        // 2. Layer priority as tiebreaker (lower = higher priority)
+        effectiveMatches.sort((a, b) => {
+            // First compare position score
+            if (a.positionScore !== b.positionScore) {
+                return a.positionScore - b.positionScore;
+            }
+            // Then compare layer priority
+            return a.priority - b.priority;
+        });
+        const bestMatch = effectiveMatches[0];
+        // Determine confidence based on match quality
+        let confidence = 'high';
+        // If multiple layers matched, reduce confidence
+        const uniqueLayers = new Set(effectiveMatches.map((m) => m.layer));
+        if (uniqueLayers.size > 1) {
+            confidence = 'medium';
+        }
+        // If the best match was before source root, reduce confidence
+        if (bestMatch.isBeforeSrcRoot) {
+            confidence = 'medium';
+        }
+        return {
+            file: filePath,
+            layer: bestMatch.layer,
+            confidence,
+            matched_pattern: bestMatch.pattern,
+        };
+    }
+    /**
+     * Detect layers for multiple files
+     */
+    detectLayers(filePaths) {
+        return filePaths.map((path) => this.detectLayer(path));
+    }
+    /**
+     * Get all detected layers from a set of files
+     */
+    getDetectedLayers(filePaths) {
+        const layers = new Set();
+        for (const path of filePaths) {
+            const assignment = this.detectLayer(path);
+            if (assignment.layer) {
+                layers.add(assignment.layer);
+            }
+        }
+        return layers;
+    }
+    /**
+     * Suggest layer structure based on detected patterns
+     */
+    suggestLayers(filePaths) {
+        const detectedLayers = this.getDetectedLayers(filePaths);
+        const result = {};
+        // Only include layers that were actually detected
+        for (const layerPattern of this.patterns) {
+            if (detectedLayers.has(layerPattern.layer)) {
+                result[layerPattern.layer] = {
+                    patterns: layerPattern.patterns,
+                    depends_on: this.getDefaultDependencies(layerPattern.layer),
+                    description: this.getLayerDescription(layerPattern.layer),
+                };
+            }
+        }
+        return result;
+    }
+    /**
+     * Get default dependencies for a layer
+     */
+    getDefaultDependencies(layer) {
+        const deps = {
+            presentation: ['application', 'shared'],
+            application: ['domain', 'infrastructure', 'shared'],
+            domain: ['shared'],
+            infrastructure: ['domain', 'shared'],
+            shared: [],
+        };
+        return deps[layer] ?? [];
+    }
+    /**
+     * Get description for a layer
+     */
+    getLayerDescription(layer) {
+        const descriptions = {
+            presentation: 'HTTP handlers, controllers, API routes',
+            application: 'Business logic, use cases, services',
+            domain: 'Domain entities, value objects, domain logic',
+            infrastructure: 'Data access, external services, infrastructure',
+            shared: 'Shared utilities, helpers, common code',
+        };
+        return descriptions[layer] ?? `${layer} layer`;
+    }
+    /**
+     * Check if a dependency from one layer to another is allowed
+     */
+    isAllowedDependency(fromLayer, toLayer, layers) {
+        const layerConfig = layers ?? this.customLayers;
+        if (!layerConfig) {
+            // Use default rules
+            const defaultDeps = this.getDefaultDependencies(fromLayer);
+            return fromLayer === toLayer || defaultDeps.includes(toLayer);
+        }
+        const fromLayerConfig = layerConfig[fromLayer];
+        if (!fromLayerConfig) {
+            return true; // Unknown layer, allow
+        }
+        return fromLayer === toLayer || fromLayerConfig.depends_on.includes(toLayer);
+    }
+    /**
+     * Find files with ambiguous layer assignments
+     */
+    findAmbiguousAssignments(filePaths) {
+        return this.detectLayers(filePaths).filter((a) => a.confidence === 'medium' || a.confidence === 'low');
+    }
+}
+/**
+ * Create a layer detector with default patterns
+ */
+export function createLayerDetector(customLayers) {
+    return new LayerDetector(customLayers);
+}

package/dist/architecture/rego-generator.d.ts

@@ -0,0 +1,25 @@
+import type { ArchitectureDefinition } from './definition-schema.js';
+export declare const GENERATED_POLICIES_DIR = ".anvil/policies/.generated";
+export declare const REGO_FILENAME = "architecture.rego";
+export declare const REGO_PACKAGE = "anvil.policies.architecture";
+/**
+ * Get the path to the generated Rego file
+ */
+export declare function getRegoPath(workspaceRoot: string): string;
+/**
+ * Check if generated Rego file exists
+ */
+export declare function regoExists(workspaceRoot: string): boolean;
+/**
+ * Check if Rego needs regeneration based on definition hash
+ */
+export declare function needsRegoRegeneration(workspaceRoot: string, definition: ArchitectureDefinition): Promise<boolean>;
+/**
+ * Write generated Rego policy file
+ */
+export declare function writeRegoPolicy(workspaceRoot: string, definition: ArchitectureDefinition): Promise<string>;
+/**
+ * Generate Rego policy content from architecture definition
+ */
+export declare function generateRegoPolicy(definition: ArchitectureDefinition): string;
+//# sourceMappingURL=rego-generator.d.ts.map

package/dist/architecture/rego-generator.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"rego-generator.d.ts","sourceRoot":"","sources":["../../src/architecture/rego-generator.ts"],"names":[],"mappings":"AAIA,OAAO,KAAK,EAAE,sBAAsB,EAAE,MAAM,wBAAwB,CAAC;AAKrE,eAAO,MAAM,sBAAsB,+BAA+B,CAAC;AACnE,eAAO,MAAM,aAAa,sBAAsB,CAAC;AACjD,eAAO,MAAM,YAAY,gCAAgC,CAAC;AAE1D;;GAEG;AACH,wBAAgB,WAAW,CAAC,aAAa,EAAE,MAAM,GAAG,MAAM,CAEzD;AAED;;GAEG;AACH,wBAAgB,UAAU,CAAC,aAAa,EAAE,MAAM,GAAG,OAAO,CAEzD;AAED;;GAEG;AACH,wBAAsB,qBAAqB,CACzC,aAAa,EAAE,MAAM,EACrB,UAAU,EAAE,sBAAsB,GACjC,OAAO,CAAC,OAAO,CAAC,CAYlB;AAOD;;GAEG;AACH,wBAAsB,eAAe,CACnC,aAAa,EAAE,MAAM,EACrB,UAAU,EAAE,sBAAsB,GACjC,OAAO,CAAC,MAAM,CAAC,CAUjB;AAED;;GAEG;AACH,wBAAgB,kBAAkB,CAAC,UAAU,EAAE,sBAAsB,GAAG,MAAM,CA8K7E"}