@eddacraft/anvil-core 0.1.0

package/dist/architecture/analyzer.d.ts

@@ -0,0 +1,123 @@
+/**
+ * Architecture analyzer
+ *
+ * Main entry point for architecture analysis. Combines layer detection,
+ * entry point detection, and dependency analysis.
+ */
+import { BaselineManager } from './baseline.js';
+import { type ArchitectureBaseline, type Layers, type EntryPoint, type LayerAssignment, type BoundaryViolation } from './types.js';
+/**
+ * Analysis result
+ */
+export interface AnalysisResult {
+    /** Detected entry points */
+    entryPoints: EntryPoint[];
+    /** Suggested layer structure */
+    layers: Layers;
+    /** Layer assignments for all files */
+    assignments: LayerAssignment[];
+    /** Files with ambiguous layer assignments */
+    ambiguous: LayerAssignment[];
+    /** Total modules analysed */
+    moduleCount: number;
+    /** Detected violations */
+    violations: BoundaryViolation[];
+    /** New violations (not in baseline) */
+    newViolations: BoundaryViolation[];
+    /** Existing violations (in baseline) */
+    existingViolations: BoundaryViolation[];
+}
+/**
+ * Analyzer options
+ */
+export interface AnalyzerOptions {
+    /** Custom layers (overrides detection) */
+    layers?: Layers;
+    /** Include test files in analysis */
+    includeTests?: boolean;
+    /** File patterns to include */
+    includePatterns?: string[];
+    /** File patterns to exclude */
+    excludePatterns?: string[];
+}
+/**
+ * Architecture analyzer
+ */
+export declare class ArchitectureAnalyzer {
+    private workspaceRoot;
+    private layerDetector;
+    private entryPointDetector;
+    private baselineManager;
+    private options;
+    constructor(workspaceRoot: string, options?: AnalyzerOptions);
+    /**
+     * Analyse the codebase and return results
+     */
+    analyse(filePaths: string[]): Promise<AnalysisResult>;
+    /**
+     * Filter files based on include/exclude patterns
+     */
+    private filterFiles;
+    /**
+     * Classify violations as new or existing
+     */
+    private classifyViolations;
+    /**
+     * Detect boundary violations by extracting imports and checking layer rules.
+     *
+     * For each import edge that crosses layer boundaries, checks whether the
+     * dependency is allowed by the layer's `depends_on` rules. Disallowed
+     * cross-layer imports are returned as BoundaryViolations.
+     */
+    private detectViolations;
+    /**
+     * Create a baseline from analysis results
+     */
+    createBaseline(result: AnalysisResult): ArchitectureBaseline;
+    /**
+     * Update baseline with new analysis
+     */
+    updateBaseline(result: AnalysisResult): ArchitectureBaseline | null;
+    /**
+     * Get the baseline manager
+     */
+    getBaselineManager(): BaselineManager;
+    /**
+     * Check if baseline exists
+     */
+    hasBaseline(): boolean;
+    /**
+     * Load existing baseline
+     */
+    loadBaseline(): ArchitectureBaseline | null;
+}
+/**
+ * Create an architecture analyzer
+ */
+export declare function createArchitectureAnalyzer(workspaceRoot: string, options?: AnalyzerOptions): ArchitectureAnalyzer;
+/**
+ * Quick analysis helper - analyse and optionally create baseline
+ */
+export declare function analyseArchitecture(workspaceRoot: string, filePaths: string[], options?: AnalyzerOptions & {
+    createBaseline?: boolean;
+}): Promise<AnalysisResult & {
+    baseline?: ArchitectureBaseline;
+}>;
+/**
+ * Options for baseline inference
+ */
+export interface InferBaselineOptions extends AnalyzerOptions {
+    /** Save baseline to .anvil/architecture.json (default: true) */
+    save?: boolean;
+}
+/**
+ * Infer architecture baseline from codebase
+ *
+ * Scans the workspace, detects layers and entry points, and creates a baseline.
+ * This is the primary entry point for `anvil init` architecture setup.
+ */
+export declare function inferBaseline(workspaceRoot: string, options?: InferBaselineOptions): Promise<{
+    result: AnalysisResult;
+    baseline: ArchitectureBaseline;
+}>;
+//# sourceMappingURL=analyzer.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"analyzer.d.ts","sourceRoot":"","sources":["../../src/architecture/analyzer.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAQH,OAAO,EAAE,eAAe,EAAyB,MAAM,eAAe,CAAC;AAEvE,OAAO,EACL,KAAK,oBAAoB,EACzB,KAAK,MAAM,EAEX,KAAK,UAAU,EACf,KAAK,eAAe,EACpB,KAAK,iBAAiB,EAKvB,MAAM,YAAY,CAAC;AAIpB;;GAEG;AACH,MAAM,WAAW,cAAc;IAC7B,4BAA4B;IAC5B,WAAW,EAAE,UAAU,EAAE,CAAC;IAC1B,gCAAgC;IAChC,MAAM,EAAE,MAAM,CAAC;IACf,sCAAsC;IACtC,WAAW,EAAE,eAAe,EAAE,CAAC;IAC/B,6CAA6C;IAC7C,SAAS,EAAE,eAAe,EAAE,CAAC;IAC7B,6BAA6B;IAC7B,WAAW,EAAE,MAAM,CAAC;IACpB,0BAA0B;IAC1B,UAAU,EAAE,iBAAiB,EAAE,CAAC;IAChC,uCAAuC;IACvC,aAAa,EAAE,iBAAiB,EAAE,CAAC;IACnC,wCAAwC;IACxC,kBAAkB,EAAE,iBAAiB,EAAE,CAAC;CACzC;AAED;;GAEG;AACH,MAAM,WAAW,eAAe;IAC9B,0CAA0C;IAC1C,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,qCAAqC;IACrC,YAAY,CAAC,EAAE,OAAO,CAAC;IACvB,+BAA+B;IAC/B,eAAe,CAAC,EAAE,MAAM,EAAE,CAAC;IAC3B,+BAA+B;IAC/B,eAAe,CAAC,EAAE,MAAM,EAAE,CAAC;CAC5B;AA0BD;;GAEG;AACH,qBAAa,oBAAoB;IAC/B,OAAO,CAAC,aAAa,CAAS;IAC9B,OAAO,CAAC,aAAa,CAAgB;IACrC,OAAO,CAAC,kBAAkB,CAAqB;IAC/C,OAAO,CAAC,eAAe,CAAkB;IACzC,OAAO,CAAC,OAAO,CAA4B;gBAE/B,aAAa,EAAE,MAAM,EAAE,OAAO,GAAE,eAAoB;IAchE;;OAEG;IACG,OAAO,CAAC,SAAS,EAAE,MAAM,EAAE,GAAG,OAAO,CAAC,cAAc,CAAC;IAwC3D;;OAEG;IACH,OAAO,CAAC,WAAW;IAoBnB;;OAEG;IACH,OAAO,CAAC,kBAAkB;IAwC1B;;;;;;OAMG;IACH,OAAO,CAAC,gBAAgB;IA2CxB;;OAEG;IACH,cAAc,CAAC,MAAM,EAAE,cAAc,GAAG,oBAAoB;IAmB5D;;OAEG;IACH,cAAc,CAAC,MAAM,EAAE,cAAc,GAAG,oBAAoB,GAAG,IAAI;IAkBnE;;OAEG;IACH,kBAAkB,IAAI,eAAe;IAIrC;;OAEG;IACH,WAAW,IAAI,OAAO;IAItB;;OAEG;IACH,YAAY,IAAI,oBAAoB,GAAG,IAAI;CAG5C;AAED;;GAEG;AACH,wBAAgB,0BAA0B,CACxC,aAAa,EAAE,MAAM,EACrB,OAAO,CAAC,EAAE,eAAe,GACxB,oBAAoB,CAEtB;AAED;;GAEG;AACH,wBAAsB,mBAAmB,CACvC,aAAa,EAAE,MAAM,EACrB,SAAS,EAAE,MAAM,EAAE,EACnB,OAAO,CAAC,EAAE,eAAe,GAAG;IAAE,cAAc,CAAC,EAAE,OAAO,CAAA;CAAE,GACvD,OAAO,CAAC,cAAc,GAAG;IAAE,QAAQ,CAAC,EAAE,oBAAoB,CAAA;CAAE,CAAC,CAU/D;AAED;;GAEG;AACH,MAAM,WAAW,oBAAqB,SAAQ,eAAe;IAC3D,gEAAgE;IAChE,IAAI,CAAC,EAAE,OAAO,CAAC;CAChB;AAED;;;;;GAKG;AACH,wBAAsB,aAAa,CACjC,aAAa,EAAE,MAAM,EACrB,OAAO,CAAC,EAAE,oBAAoB,GAC7B,OAAO,CAAC;IAAE,MAAM,EAAE,cAAc,CAAC;IAAC,QAAQ,EAAE,oBAAoB,CAAA;CAAE,CAAC,CAWrE"}

package/dist/architecture/analyzer.js

@@ -0,0 +1,321 @@
+/**
+ * Architecture analyzer
+ *
+ * Main entry point for architecture analysis. Combines layer detection,
+ * entry point detection, and dependency analysis.
+ */
+import { readdirSync, statSync } from 'node:fs';
+import { join } from 'node:path';
+import { minimatch } from 'minimatch';
+import { createDebugger } from '../utils/debug.js';
+import { createLayerDetector } from './layer-detector.js';
+import { createEntryPointDetector } from './entry-detector.js';
+import { createBaselineManager } from './baseline.js';
+import { extractImportsFromFiles, toDependencyEdge } from './edge-detector.js';
+import { createViolationId, createDefaultLayers, createDefaultBoundaries, } from './types.js';
+const debug = createDebugger('architecture');
+/**
+ * Default exclude patterns
+ */
+const DEFAULT_EXCLUDE_PATTERNS = [
+    '**/node_modules/**',
+    '**/.git/**',
+    '**/dist/**',
+    '**/build/**',
+    '**/coverage/**',
+    '**/*.d.ts',
+];
+/**
+ * Default include patterns
+ */
+const DEFAULT_INCLUDE_PATTERNS = [
+    '**/*.ts',
+    '**/*.tsx',
+    '**/*.js',
+    '**/*.jsx',
+    '**/*.mjs',
+    '**/*.cjs',
+];
+/**
+ * Architecture analyzer
+ */
+export class ArchitectureAnalyzer {
+    workspaceRoot;
+    layerDetector;
+    entryPointDetector;
+    baselineManager;
+    options;
+    constructor(workspaceRoot, options = {}) {
+        this.workspaceRoot = workspaceRoot;
+        this.options = {
+            layers: options.layers ?? createDefaultLayers(),
+            includeTests: options.includeTests ?? false,
+            includePatterns: options.includePatterns ?? DEFAULT_INCLUDE_PATTERNS,
+            excludePatterns: options.excludePatterns ?? DEFAULT_EXCLUDE_PATTERNS,
+        };
+        this.layerDetector = createLayerDetector(this.options.layers);
+        this.entryPointDetector = createEntryPointDetector(workspaceRoot);
+        this.baselineManager = createBaselineManager(workspaceRoot);
+    }
+    /**
+     * Analyse the codebase and return results
+     */
+    async analyse(filePaths) {
+        // Filter files
+        const filteredPaths = this.filterFiles(filePaths);
+        // Detect entry points
+        let entryPoints = this.entryPointDetector.detectEntryPoints(filteredPaths);
+        if (!this.options.includeTests) {
+            entryPoints = this.entryPointDetector.filterNonTestEntryPoints(entryPoints);
+        }
+        // Detect layers
+        const assignments = this.layerDetector.detectLayers(filteredPaths);
+        const ambiguous = this.layerDetector.findAmbiguousAssignments(filteredPaths);
+        // Suggest layers based on detected patterns
+        const suggestedLayers = this.layerDetector.suggestLayers(filteredPaths);
+        // Use suggested layers if no custom layers provided
+        const layers = Object.keys(this.options.layers).length > 0 ? this.options.layers : suggestedLayers;
+        // Detect violations by extracting imports and checking against layer boundaries
+        const violations = this.detectViolations(filteredPaths, layers);
+        // Classify violations as new or existing
+        const baseline = this.baselineManager.load();
+        const { newViolations, existingViolations } = this.classifyViolations(violations, baseline);
+        return {
+            entryPoints,
+            layers,
+            assignments,
+            ambiguous,
+            moduleCount: filteredPaths.length,
+            violations,
+            newViolations,
+            existingViolations,
+        };
+    }
+    /**
+     * Filter files based on include/exclude patterns
+     */
+    filterFiles(filePaths) {
+        return filePaths.filter((path) => {
+            // Check excludes
+            for (const pattern of this.options.excludePatterns) {
+                if (minimatch(path, pattern, { matchBase: true })) {
+                    return false;
+                }
+            }
+            // Check includes
+            for (const pattern of this.options.includePatterns) {
+                if (minimatch(path, pattern, { matchBase: true })) {
+                    return true;
+                }
+            }
+            return false;
+        });
+    }
+    /**
+     * Classify violations as new or existing
+     */
+    classifyViolations(violations, baseline) {
+        if (!baseline) {
+            // No baseline = all violations are new
+            return {
+                newViolations: violations.map((v) => ({ ...v, is_new: true })),
+                existingViolations: [],
+            };
+        }
+        const baselineIds = new Set(baseline.baseline_snapshot.violations.map((v) => v.id));
+        const newViolations = [];
+        const existingViolations = [];
+        for (const violation of violations) {
+            const id = createViolationId(violation.edge.from, violation.edge.to, violation.edge.line);
+            if (baselineIds.has(id)) {
+                existingViolations.push({
+                    ...violation,
+                    is_new: false,
+                    baseline_id: id,
+                });
+            }
+            else {
+                newViolations.push({
+                    ...violation,
+                    is_new: true,
+                });
+            }
+        }
+        return { newViolations, existingViolations };
+    }
+    /**
+     * Detect boundary violations by extracting imports and checking layer rules.
+     *
+     * For each import edge that crosses layer boundaries, checks whether the
+     * dependency is allowed by the layer's `depends_on` rules. Disallowed
+     * cross-layer imports are returned as BoundaryViolations.
+     */
+    detectViolations(filePaths, layers) {
+        const violations = [];
+        // Extract all import edges from source files
+        const edges = extractImportsFromFiles(filePaths, this.workspaceRoot);
+        // Build boundary rules (disallowed layer pairs)
+        const boundaries = createDefaultBoundaries(layers);
+        const boundaryMap = new Map();
+        for (const boundary of boundaries) {
+            boundaryMap.set(`${boundary.from}->${boundary.to}`, boundary);
+        }
+        // Check each edge against layer rules
+        for (const edge of edges) {
+            const fromAssignment = this.layerDetector.detectLayer(edge.from);
+            const toAssignment = this.layerDetector.detectLayer(edge.to);
+            const fromLayer = fromAssignment.layer;
+            const toLayer = toAssignment.layer;
+            // Skip if either file has no layer assignment or they're in the same layer
+            if (!fromLayer || !toLayer || fromLayer === toLayer) {
+                continue;
+            }
+            // Check if this cross-layer dependency is allowed
+            if (!this.layerDetector.isAllowedDependency(fromLayer, toLayer, layers)) {
+                const boundaryKey = `${fromLayer}->${toLayer}`;
+                const boundary = boundaryMap.get(boundaryKey);
+                violations.push({
+                    edge: toDependencyEdge(edge, fromLayer, toLayer),
+                    boundary,
+                    is_new: true, // Will be reclassified by classifyViolations
+                });
+            }
+        }
+        debug(`detected ${violations.length} boundary violations from ${edges.length} edges`);
+        return violations;
+    }
+    /**
+     * Create a baseline from analysis results
+     */
+    createBaseline(result) {
+        const violations = result.violations.map((v) => ({
+            id: createViolationId(v.edge.from, v.edge.to, v.edge.line),
+            from_layer: v.edge.from_layer ?? 'unknown',
+            to_layer: v.edge.to_layer ?? 'unknown',
+            from_file: v.edge.from,
+            to_file: v.edge.to,
+            import_line: v.edge.line,
+        }));
+        return this.baselineManager.create({
+            entryPoints: result.entryPoints,
+            layers: result.layers,
+            boundaries: createDefaultBoundaries(result.layers),
+            violations,
+            moduleCount: result.moduleCount,
+        });
+    }
+    /**
+     * Update baseline with new analysis
+     */
+    updateBaseline(result) {
+        const violations = result.violations.map((v) => ({
+            id: createViolationId(v.edge.from, v.edge.to, v.edge.line),
+            from_layer: v.edge.from_layer ?? 'unknown',
+            to_layer: v.edge.to_layer ?? 'unknown',
+            from_file: v.edge.from,
+            to_file: v.edge.to,
+            import_line: v.edge.line,
+        }));
+        return this.baselineManager.update({
+            entryPoints: result.entryPoints,
+            layers: result.layers,
+            violations,
+            moduleCount: result.moduleCount,
+        });
+    }
+    /**
+     * Get the baseline manager
+     */
+    getBaselineManager() {
+        return this.baselineManager;
+    }
+    /**
+     * Check if baseline exists
+     */
+    hasBaseline() {
+        return this.baselineManager.exists();
+    }
+    /**
+     * Load existing baseline
+     */
+    loadBaseline() {
+        return this.baselineManager.load();
+    }
+}
+/**
+ * Create an architecture analyzer
+ */
+export function createArchitectureAnalyzer(workspaceRoot, options) {
+    return new ArchitectureAnalyzer(workspaceRoot, options);
+}
+/**
+ * Quick analysis helper - analyse and optionally create baseline
+ */
+export async function analyseArchitecture(workspaceRoot, filePaths, options) {
+    const analyzer = createArchitectureAnalyzer(workspaceRoot, options);
+    const result = await analyzer.analyse(filePaths);
+    if (options?.createBaseline) {
+        const baseline = analyzer.createBaseline(result);
+        return { ...result, baseline };
+    }
+    return result;
+}
+/**
+ * Infer architecture baseline from codebase
+ *
+ * Scans the workspace, detects layers and entry points, and creates a baseline.
+ * This is the primary entry point for `anvil init` architecture setup.
+ */
+export async function inferBaseline(workspaceRoot, options) {
+    const analyzer = createArchitectureAnalyzer(workspaceRoot, options);
+    const filePaths = collectSourceFiles(workspaceRoot, options);
+    const result = await analyzer.analyse(filePaths);
+    const baseline = analyzer.createBaseline(result);
+    if (options?.save !== false) {
+        analyzer.getBaselineManager().save(baseline);
+    }
+    return { result, baseline };
+}
+/**
+ * Collect source files from workspace
+ */
+function collectSourceFiles(workspaceRoot, options) {
+    const includePatterns = options?.includePatterns ?? DEFAULT_INCLUDE_PATTERNS;
+    const excludePatterns = options?.excludePatterns ?? DEFAULT_EXCLUDE_PATTERNS;
+    const files = [];
+    function walk(dir, relativePath = '') {
+        let entries;
+        try {
+            entries = readdirSync(dir);
+        }
+        catch (err) {
+            debug('skipping directory (read error):', err);
+            return;
+        }
+        for (const entry of entries) {
+            const fullPath = join(dir, entry);
+            const relPath = relativePath ? `${relativePath}/${entry}` : entry;
+            if (excludePatterns.some((p) => minimatch(relPath, p, { matchBase: true }))) {
+                continue;
+            }
+            let stat;
+            try {
+                stat = statSync(fullPath);
+            }
+            catch (err) {
+                debug('skipping entry (stat error):', err);
+                continue;
+            }
+            if (stat.isDirectory()) {
+                walk(fullPath, relPath);
+            }
+            else if (stat.isFile()) {
+                if (includePatterns.some((p) => minimatch(relPath, p, { matchBase: true }))) {
+                    files.push(relPath);
+                }
+            }
+        }
+    }
+    walk(workspaceRoot);
+    return files;
+}

package/dist/architecture/baseline.d.ts

@@ -0,0 +1,112 @@
+/**
+ * Architecture baseline storage
+ *
+ * Handles reading/writing .anvil/architecture.json
+ */
+import { type ArchitectureBaseline, type Layers, type EntryPoint, type Boundary, type BaselineViolation } from './types.js';
+/**
+ * Default baseline file path
+ */
+export declare const BASELINE_FILENAME = "architecture.json";
+export declare const ANVIL_DIR = ".anvil";
+/**
+ * Get the full path to the baseline file
+ */
+export declare function getBaselinePath(workspaceRoot: string): string;
+/**
+ * Check if a baseline exists
+ */
+export declare function baselineExists(workspaceRoot: string): boolean;
+/**
+ * Load the architecture baseline
+ */
+export declare function loadBaseline(workspaceRoot: string): ArchitectureBaseline | null;
+/**
+ * Save the architecture baseline
+ */
+export declare function saveBaseline(workspaceRoot: string, baseline: ArchitectureBaseline): void;
+/**
+ * Create a new baseline with defaults
+ */
+export declare function createBaseline(options: {
+    entryPoints?: EntryPoint[];
+    layers?: Layers;
+    boundaries?: Boundary[];
+    violations?: BaselineViolation[];
+    moduleCount?: number;
+}): ArchitectureBaseline;
+/**
+ * Update an existing baseline
+ */
+export declare function updateBaseline(existing: ArchitectureBaseline, updates: Partial<{
+    entryPoints: EntryPoint[];
+    layers: Layers;
+    boundaries: Boundary[];
+    violations: BaselineViolation[];
+    moduleCount: number;
+}>): ArchitectureBaseline;
+/**
+ * Merge new violations into baseline (for incremental updates)
+ */
+export declare function mergeViolations(existing: BaselineViolation[], newViolations: BaselineViolation[]): BaselineViolation[];
+/**
+ * Find violations that are NEW (not in baseline)
+ */
+export declare function findNewViolations(current: BaselineViolation[], baseline: BaselineViolation[]): BaselineViolation[];
+/**
+ * Find violations that were FIXED (in baseline but not current)
+ */
+export declare function findFixedViolations(current: BaselineViolation[], baseline: BaselineViolation[]): BaselineViolation[];
+/**
+ * Baseline manager for convenient operations
+ */
+export declare class BaselineManager {
+    private workspaceRoot;
+    private baseline;
+    constructor(workspaceRoot: string);
+    /**
+     * Check if baseline exists
+     */
+    exists(): boolean;
+    /**
+     * Load baseline (cached)
+     */
+    load(): ArchitectureBaseline | null;
+    /**
+     * Force reload baseline
+     */
+    reload(): ArchitectureBaseline | null;
+    /**
+     * Save baseline
+     */
+    save(baseline: ArchitectureBaseline): void;
+    /**
+     * Create and save a new baseline
+     */
+    create(options: Parameters<typeof createBaseline>[0]): ArchitectureBaseline;
+    /**
+     * Update and save existing baseline
+     */
+    update(updates: Parameters<typeof updateBaseline>[1]): ArchitectureBaseline | null;
+    /**
+     * Get layers from baseline or defaults
+     */
+    getLayers(): Layers;
+    /**
+     * Get boundaries from baseline or defaults
+     */
+    getBoundaries(): Boundary[];
+    /**
+     * Check if a violation is new
+     */
+    isNewViolation(violation: BaselineViolation): boolean;
+    /**
+     * Get baseline path
+     */
+    getPath(): string;
+}
+/**
+ * Create a baseline manager
+ */
+export declare function createBaselineManager(workspaceRoot: string): BaselineManager;
+//# sourceMappingURL=baseline.d.ts.map

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

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