@eddacraft/anvil-core 0.1.0

package/dist/architecture/baseline.js

@@ -0,0 +1,245 @@
+/**
+ * Architecture baseline storage
+ *
+ * Handles reading/writing .anvil/architecture.json
+ */
+import { existsSync, readFileSync, writeFileSync, mkdirSync } from 'node:fs';
+import { join, dirname } from 'node:path';
+import { ArchitectureBaselineSchema, createDefaultLayers, createDefaultBoundaries, } from './types.js';
+import { createDebugger } from '../utils/debug.js';
+const debug = createDebugger('architecture');
+/**
+ * Default baseline file path
+ */
+export const BASELINE_FILENAME = 'architecture.json';
+export const ANVIL_DIR = '.anvil';
+/**
+ * Get the full path to the baseline file
+ */
+export function getBaselinePath(workspaceRoot) {
+    return join(workspaceRoot, ANVIL_DIR, BASELINE_FILENAME);
+}
+/**
+ * Check if a baseline exists
+ */
+export function baselineExists(workspaceRoot) {
+    return existsSync(getBaselinePath(workspaceRoot));
+}
+/**
+ * Load the architecture baseline
+ */
+export function loadBaseline(workspaceRoot) {
+    const path = getBaselinePath(workspaceRoot);
+    if (!existsSync(path)) {
+        debug('no baseline file found', path);
+        return null;
+    }
+    try {
+        debug('loading baseline from', path);
+        const content = readFileSync(path, 'utf-8');
+        const data = JSON.parse(content);
+        // Validate against schema
+        const result = ArchitectureBaselineSchema.safeParse(data);
+        if (!result.success) {
+            debug('invalid baseline schema', result.error.format());
+            console.error('Invalid architecture baseline:', result.error.format());
+            return null;
+        }
+        debug('baseline loaded', {
+            modules: result.data.baseline_snapshot.module_count,
+            violations: result.data.baseline_snapshot.violations.length,
+        });
+        return result.data;
+    }
+    catch (error) {
+        debug('failed to load baseline', error instanceof Error ? error : undefined);
+        console.error('Failed to load architecture baseline:', error);
+        return null;
+    }
+}
+/**
+ * Save the architecture baseline
+ */
+export function saveBaseline(workspaceRoot, baseline) {
+    debug('saving baseline', { modules: baseline.baseline_snapshot.module_count });
+    const path = getBaselinePath(workspaceRoot);
+    const dir = dirname(path);
+    // Ensure directory exists
+    if (!existsSync(dir)) {
+        mkdirSync(dir, { recursive: true });
+    }
+    // Validate before saving
+    const result = ArchitectureBaselineSchema.safeParse(baseline);
+    if (!result.success) {
+        throw new Error(`Invalid baseline data: ${result.error.format()}`);
+    }
+    // Write with pretty formatting for human readability
+    writeFileSync(path, JSON.stringify(baseline, null, 2) + '\n', 'utf-8');
+}
+/**
+ * Create a new baseline with defaults
+ */
+export function createBaseline(options) {
+    const now = new Date().toISOString();
+    const layers = options.layers ?? createDefaultLayers();
+    const boundaries = options.boundaries ?? createDefaultBoundaries(layers);
+    return {
+        schema_version: '0.1.0',
+        created_at: now,
+        updated_at: now,
+        entry_points: options.entryPoints ?? [],
+        layers,
+        boundaries,
+        baseline_snapshot: {
+            module_count: options.moduleCount ?? 0,
+            timestamp: now,
+            violations: options.violations ?? [],
+        },
+    };
+}
+/**
+ * Update an existing baseline
+ */
+export function updateBaseline(existing, updates) {
+    const now = new Date().toISOString();
+    return {
+        ...existing,
+        updated_at: now,
+        entry_points: updates.entryPoints ?? existing.entry_points,
+        layers: updates.layers ?? existing.layers,
+        boundaries: updates.boundaries ?? existing.boundaries,
+        baseline_snapshot: {
+            ...existing.baseline_snapshot,
+            module_count: updates.moduleCount ?? existing.baseline_snapshot.module_count,
+            violations: updates.violations ?? existing.baseline_snapshot.violations,
+            timestamp: now,
+        },
+    };
+}
+/**
+ * Merge new violations into baseline (for incremental updates)
+ */
+export function mergeViolations(existing, newViolations) {
+    const byId = new Map();
+    // Add existing
+    for (const v of existing) {
+        byId.set(v.id, v);
+    }
+    // Add/update new
+    for (const v of newViolations) {
+        byId.set(v.id, v);
+    }
+    return Array.from(byId.values());
+}
+/**
+ * Find violations that are NEW (not in baseline)
+ */
+export function findNewViolations(current, baseline) {
+    const baselineIds = new Set(baseline.map((v) => v.id));
+    return current.filter((v) => !baselineIds.has(v.id));
+}
+/**
+ * Find violations that were FIXED (in baseline but not current)
+ */
+export function findFixedViolations(current, baseline) {
+    const currentIds = new Set(current.map((v) => v.id));
+    return baseline.filter((v) => !currentIds.has(v.id));
+}
+/**
+ * Baseline manager for convenient operations
+ */
+export class BaselineManager {
+    workspaceRoot;
+    baseline = null;
+    constructor(workspaceRoot) {
+        this.workspaceRoot = workspaceRoot;
+    }
+    /**
+     * Check if baseline exists
+     */
+    exists() {
+        return baselineExists(this.workspaceRoot);
+    }
+    /**
+     * Load baseline (cached)
+     */
+    load() {
+        if (!this.baseline) {
+            this.baseline = loadBaseline(this.workspaceRoot);
+        }
+        return this.baseline;
+    }
+    /**
+     * Force reload baseline
+     */
+    reload() {
+        this.baseline = loadBaseline(this.workspaceRoot);
+        return this.baseline;
+    }
+    /**
+     * Save baseline
+     */
+    save(baseline) {
+        saveBaseline(this.workspaceRoot, baseline);
+        this.baseline = baseline;
+    }
+    /**
+     * Create and save a new baseline
+     */
+    create(options) {
+        const baseline = createBaseline(options);
+        this.save(baseline);
+        return baseline;
+    }
+    /**
+     * Update and save existing baseline
+     */
+    update(updates) {
+        const existing = this.load();
+        if (!existing) {
+            return null;
+        }
+        const updated = updateBaseline(existing, updates);
+        this.save(updated);
+        return updated;
+    }
+    /**
+     * Get layers from baseline or defaults
+     */
+    getLayers() {
+        const baseline = this.load();
+        return baseline?.layers ?? createDefaultLayers();
+    }
+    /**
+     * Get boundaries from baseline or defaults
+     */
+    getBoundaries() {
+        const baseline = this.load();
+        if (baseline) {
+            return baseline.boundaries;
+        }
+        return createDefaultBoundaries(createDefaultLayers());
+    }
+    /**
+     * Check if a violation is new
+     */
+    isNewViolation(violation) {
+        const baseline = this.load();
+        if (!baseline) {
+            return true; // No baseline = all violations are new
+        }
+        return !baseline.baseline_snapshot.violations.some((v) => v.id === violation.id);
+    }
+    /**
+     * Get baseline path
+     */
+    getPath() {
+        return getBaselinePath(this.workspaceRoot);
+    }
+}
+/**
+ * Create a baseline manager
+ */
+export function createBaselineManager(workspaceRoot) {
+    return new BaselineManager(workspaceRoot);
+}

package/dist/architecture/compiler.d.ts

@@ -0,0 +1,24 @@
+import type { ArchitectureDefinition } from './definition-schema.js';
+export interface CompileResult {
+    dcConfig: {
+        path: string;
+        regenerated: boolean;
+    };
+    regoPolicy: {
+        path: string;
+        regenerated: boolean;
+    };
+    definition: ArchitectureDefinition;
+}
+export interface CompileOptions {
+    force?: boolean;
+    skipDC?: boolean;
+    skipRego?: boolean;
+}
+export declare function compileArchitecture(workspaceRoot: string, options?: CompileOptions): Promise<CompileResult>;
+export declare function needsCompilation(workspaceRoot: string): Promise<{
+    dc: boolean;
+    rego: boolean;
+    any: boolean;
+}>;
+//# sourceMappingURL=compiler.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"compiler.d.ts","sourceRoot":"","sources":["../../src/architecture/compiler.ts"],"names":[],"mappings":"AAoBA,OAAO,KAAK,EAAE,sBAAsB,EAAE,MAAM,wBAAwB,CAAC;AAErE,MAAM,WAAW,aAAa;IAC5B,QAAQ,EAAE;QAAE,IAAI,EAAE,MAAM,CAAC;QAAC,WAAW,EAAE,OAAO,CAAA;KAAE,CAAC;IACjD,UAAU,EAAE;QAAE,IAAI,EAAE,MAAM,CAAC;QAAC,WAAW,EAAE,OAAO,CAAA;KAAE,CAAC;IACnD,UAAU,EAAE,sBAAsB,CAAC;CACpC;AAED,MAAM,WAAW,cAAc;IAC7B,KAAK,CAAC,EAAE,OAAO,CAAC;IAChB,MAAM,CAAC,EAAE,OAAO,CAAC;IACjB,QAAQ,CAAC,EAAE,OAAO,CAAC;CACpB;AAED,wBAAsB,mBAAmB,CACvC,aAAa,EAAE,MAAM,EACrB,OAAO,GAAE,cAAmB,GAC3B,OAAO,CAAC,aAAa,CAAC,CAgDxB;AAED,wBAAsB,gBAAgB,CAAC,aAAa,EAAE,MAAM,GAAG,OAAO,CAAC;IACrE,EAAE,EAAE,OAAO,CAAC;IACZ,IAAI,EAAE,OAAO,CAAC;IACd,GAAG,EAAE,OAAO,CAAC;CACd,CAAC,CAYD"}

package/dist/architecture/compiler.js

@@ -0,0 +1,57 @@
+import { architectureYamlExists, parseArchitectureDefinition, mergeWithTemplate, } from './yaml-parser.js';
+import { createDebugger } from '../utils/debug.js';
+const debug = createDebugger('compiler');
+import { needsRegeneration, writeDCConfig, dcConfigExists, getDCConfigPath, } from './dc-generator.js';
+import { needsRegoRegeneration, writeRegoPolicy, regoExists, getRegoPath, } from './rego-generator.js';
+export async function compileArchitecture(workspaceRoot, options = {}) {
+    debug('compiling architecture', { workspaceRoot, options });
+    if (!architectureYamlExists(workspaceRoot)) {
+        throw new Error('No architecture.yaml found. Run: anvil architecture init');
+    }
+    const definition = await parseArchitectureDefinition(workspaceRoot);
+    const merged = mergeWithTemplate(definition);
+    debug('definition parsed', {
+        template: merged.template,
+        layerCount: Object.keys(merged.layers).length,
+    });
+    const result = {
+        dcConfig: { path: getDCConfigPath(workspaceRoot), regenerated: false },
+        regoPolicy: { path: getRegoPath(workspaceRoot), regenerated: false },
+        definition: merged,
+    };
+    if (!options.skipDC) {
+        const needsDC = options.force ||
+            !dcConfigExists(workspaceRoot) ||
+            (await needsRegeneration(workspaceRoot, merged));
+        if (needsDC) {
+            debug('regenerating dependency-cruiser config');
+            result.dcConfig.path = await writeDCConfig(workspaceRoot, merged);
+            result.dcConfig.regenerated = true;
+        }
+    }
+    if (!options.skipRego) {
+        const needsRego = options.force ||
+            !regoExists(workspaceRoot) ||
+            (await needsRegoRegeneration(workspaceRoot, merged));
+        if (needsRego) {
+            debug('regenerating Rego policy');
+            result.regoPolicy.path = await writeRegoPolicy(workspaceRoot, merged);
+            result.regoPolicy.regenerated = true;
+        }
+    }
+    debug('compilation complete', {
+        dcRegenerated: result.dcConfig.regenerated,
+        regoRegenerated: result.regoPolicy.regenerated,
+    });
+    return result;
+}
+export async function needsCompilation(workspaceRoot) {
+    if (!architectureYamlExists(workspaceRoot)) {
+        return { dc: false, rego: false, any: false };
+    }
+    const definition = await parseArchitectureDefinition(workspaceRoot);
+    const merged = mergeWithTemplate(definition);
+    const dc = !dcConfigExists(workspaceRoot) || (await needsRegeneration(workspaceRoot, merged));
+    const rego = !regoExists(workspaceRoot) || (await needsRegoRegeneration(workspaceRoot, merged));
+    return { dc, rego, any: dc || rego };
+}

package/dist/architecture/context.d.ts

@@ -0,0 +1,129 @@
+import { z } from 'zod';
+export declare const ArchViolationSeveritySchema: z.ZodEnum<{
+    error: "error";
+    info: "info";
+    warn: "warn";
+    ignore: "ignore";
+}>;
+export type ArchViolationSeverity = z.infer<typeof ArchViolationSeveritySchema>;
+export declare const ArchViolationSchema: z.ZodObject<{
+    from: z.ZodString;
+    to: z.ZodString;
+    rule: z.ZodString;
+    severity: z.ZodEnum<{
+        error: "error";
+        info: "info";
+        warn: "warn";
+        ignore: "ignore";
+    }>;
+    is_circular: z.ZodBoolean;
+    cycle: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    is_new: z.ZodBoolean;
+    from_layer: z.ZodNullable<z.ZodString>;
+    to_layer: z.ZodNullable<z.ZodString>;
+}, z.core.$strip>;
+export type ArchViolation = z.infer<typeof ArchViolationSchema>;
+export declare const ModuleInfoSchema: z.ZodObject<{
+    path: z.ZodString;
+    layer: z.ZodNullable<z.ZodString>;
+    confidence: z.ZodOptional<z.ZodEnum<{
+        high: "high";
+        medium: "medium";
+        low: "low";
+    }>>;
+    matched_pattern: z.ZodOptional<z.ZodString>;
+    dependency_count: z.ZodNumber;
+    dependent_count: z.ZodNumber;
+    is_orphan: z.ZodBoolean;
+}, z.core.$strip>;
+export type ModuleInfo = z.infer<typeof ModuleInfoSchema>;
+export declare const LayerStatsSchema: z.ZodObject<{
+    name: z.ZodString;
+    module_count: z.ZodNumber;
+    violations_from: z.ZodNumber;
+    violations_to: z.ZodNumber;
+    depends_on: z.ZodArray<z.ZodString>;
+    patterns: z.ZodArray<z.ZodString>;
+}, z.core.$strip>;
+export type LayerStats = z.infer<typeof LayerStatsSchema>;
+export declare const ArchitectureContextSchema: z.ZodObject<{
+    timestamp: z.ZodString;
+    summary: z.ZodObject<{
+        total_modules: z.ZodNumber;
+        total_violations: z.ZodNumber;
+        new_violations: z.ZodNumber;
+        error_count: z.ZodNumber;
+        warn_count: z.ZodNumber;
+        info_count: z.ZodNumber;
+        circular_count: z.ZodNumber;
+        orphan_count: z.ZodNumber;
+        layer_violation_count: z.ZodNumber;
+        baseline_loaded: z.ZodBoolean;
+    }, z.core.$strip>;
+    violations: z.ZodArray<z.ZodObject<{
+        from: z.ZodString;
+        to: z.ZodString;
+        rule: z.ZodString;
+        severity: z.ZodEnum<{
+            error: "error";
+            info: "info";
+            warn: "warn";
+            ignore: "ignore";
+        }>;
+        is_circular: z.ZodBoolean;
+        cycle: z.ZodOptional<z.ZodArray<z.ZodString>>;
+        is_new: z.ZodBoolean;
+        from_layer: z.ZodNullable<z.ZodString>;
+        to_layer: z.ZodNullable<z.ZodString>;
+    }, z.core.$strip>>;
+    layers: z.ZodRecord<z.ZodString, z.ZodObject<{
+        name: z.ZodString;
+        module_count: z.ZodNumber;
+        violations_from: z.ZodNumber;
+        violations_to: z.ZodNumber;
+        depends_on: z.ZodArray<z.ZodString>;
+        patterns: z.ZodArray<z.ZodString>;
+    }, z.core.$strip>>;
+    modules: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        path: z.ZodString;
+        layer: z.ZodNullable<z.ZodString>;
+        confidence: z.ZodOptional<z.ZodEnum<{
+            high: "high";
+            medium: "medium";
+            low: "low";
+        }>>;
+        matched_pattern: z.ZodOptional<z.ZodString>;
+        dependency_count: z.ZodNumber;
+        dependent_count: z.ZodNumber;
+        is_orphan: z.ZodBoolean;
+    }, z.core.$strip>>>;
+    dependencies: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodArray<z.ZodString>>>;
+    config: z.ZodOptional<z.ZodObject<{
+        config_file: z.ZodOptional<z.ZodString>;
+        scope: z.ZodOptional<z.ZodEnum<{
+            affected: "affected";
+            full: "full";
+        }>>;
+        severity_threshold: z.ZodOptional<z.ZodEnum<{
+            error: "error";
+            info: "info";
+            warn: "warn";
+        }>>;
+    }, z.core.$strip>>;
+}, z.core.$strip>;
+export type ArchitectureContext = z.infer<typeof ArchitectureContextSchema>;
+export declare function createEmptyContext(): ArchitectureContext;
+export declare class ArchitectureContextBuilder {
+    private context;
+    constructor();
+    setSummary(summary: Partial<ArchitectureContext['summary']>): this;
+    addViolation(violation: ArchViolation): this;
+    setViolations(violations: ArchViolation[]): this;
+    addLayerStats(name: string, stats: Omit<LayerStats, 'name'>): this;
+    setModules(modules: ModuleInfo[]): this;
+    setDependencies(deps: Record<string, string[]>): this;
+    setConfig(config: ArchitectureContext['config']): this;
+    build(): ArchitectureContext;
+}
+export declare function createContextBuilder(): ArchitectureContextBuilder;
+//# sourceMappingURL=context.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"context.d.ts","sourceRoot":"","sources":["../../src/architecture/context.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAExB,eAAO,MAAM,2BAA2B;;;;;EAA8C,CAAC;AACvF,MAAM,MAAM,qBAAqB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,2BAA2B,CAAC,CAAC;AAEhF,eAAO,MAAM,mBAAmB;;;;;;;;;;;;;;;iBAU9B,CAAC;AACH,MAAM,MAAM,aAAa,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,mBAAmB,CAAC,CAAC;AAEhE,eAAO,MAAM,gBAAgB;;;;;;;;;;;;iBAQ3B,CAAC;AACH,MAAM,MAAM,UAAU,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,gBAAgB,CAAC,CAAC;AAE1D,eAAO,MAAM,gBAAgB;;;;;;;iBAO3B,CAAC;AACH,MAAM,MAAM,UAAU,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,gBAAgB,CAAC,CAAC;AAE1D,eAAO,MAAM,yBAAyB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAyBpC,CAAC;AACH,MAAM,MAAM,mBAAmB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,yBAAyB,CAAC,CAAC;AAE5E,wBAAgB,kBAAkB,IAAI,mBAAmB,CAkBxD;AAED,qBAAa,0BAA0B;IACrC,OAAO,CAAC,OAAO,CAAsB;;IAMrC,UAAU,CAAC,OAAO,EAAE,OAAO,CAAC,mBAAmB,CAAC,SAAS,CAAC,CAAC,GAAG,IAAI;IAKlE,YAAY,CAAC,SAAS,EAAE,aAAa,GAAG,IAAI;IAK5C,aAAa,CAAC,UAAU,EAAE,aAAa,EAAE,GAAG,IAAI;IAKhD,aAAa,CAAC,IAAI,EAAE,MAAM,EAAE,KAAK,EAAE,IAAI,CAAC,UAAU,EAAE,MAAM,CAAC,GAAG,IAAI;IAKlE,UAAU,CAAC,OAAO,EAAE,UAAU,EAAE,GAAG,IAAI;IAKvC,eAAe,CAAC,IAAI,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,EAAE,CAAC,GAAG,IAAI;IAKrD,SAAS,CAAC,MAAM,EAAE,mBAAmB,CAAC,QAAQ,CAAC,GAAG,IAAI;IAKtD,KAAK,IAAI,mBAAmB;CAI7B;AAED,wBAAgB,oBAAoB,IAAI,0BAA0B,CAEjE"}

package/dist/architecture/context.js

@@ -0,0 +1,116 @@
+import { z } from 'zod';
+export const ArchViolationSeveritySchema = z.enum(['error', 'warn', 'info', 'ignore']);
+export const ArchViolationSchema = z.object({
+    from: z.string(),
+    to: z.string(),
+    rule: z.string(),
+    severity: ArchViolationSeveritySchema,
+    is_circular: z.boolean(),
+    cycle: z.array(z.string()).optional(),
+    is_new: z.boolean(),
+    from_layer: z.string().nullable(),
+    to_layer: z.string().nullable(),
+});
+export const ModuleInfoSchema = z.object({
+    path: z.string(),
+    layer: z.string().nullable(),
+    confidence: z.enum(['high', 'medium', 'low']).optional(),
+    matched_pattern: z.string().optional(),
+    dependency_count: z.number().int().nonnegative(),
+    dependent_count: z.number().int().nonnegative(),
+    is_orphan: z.boolean(),
+});
+export const LayerStatsSchema = z.object({
+    name: z.string(),
+    module_count: z.number().int().nonnegative(),
+    violations_from: z.number().int().nonnegative(),
+    violations_to: z.number().int().nonnegative(),
+    depends_on: z.array(z.string()),
+    patterns: z.array(z.string()),
+});
+export const ArchitectureContextSchema = z.object({
+    timestamp: z.string(),
+    summary: z.object({
+        total_modules: z.number().int().nonnegative(),
+        total_violations: z.number().int().nonnegative(),
+        new_violations: z.number().int().nonnegative(),
+        error_count: z.number().int().nonnegative(),
+        warn_count: z.number().int().nonnegative(),
+        info_count: z.number().int().nonnegative(),
+        circular_count: z.number().int().nonnegative(),
+        orphan_count: z.number().int().nonnegative(),
+        layer_violation_count: z.number().int().nonnegative(),
+        baseline_loaded: z.boolean(),
+    }),
+    violations: z.array(ArchViolationSchema),
+    layers: z.record(z.string(), LayerStatsSchema),
+    modules: z.array(ModuleInfoSchema).optional(),
+    dependencies: z.record(z.string(), z.array(z.string())).optional(),
+    config: z
+        .object({
+        config_file: z.string().optional(),
+        scope: z.enum(['affected', 'full']).optional(),
+        severity_threshold: z.enum(['error', 'warn', 'info']).optional(),
+    })
+        .optional(),
+});
+export function createEmptyContext() {
+    return {
+        timestamp: new Date().toISOString(),
+        summary: {
+            total_modules: 0,
+            total_violations: 0,
+            new_violations: 0,
+            error_count: 0,
+            warn_count: 0,
+            info_count: 0,
+            circular_count: 0,
+            orphan_count: 0,
+            layer_violation_count: 0,
+            baseline_loaded: false,
+        },
+        violations: [],
+        layers: {},
+    };
+}
+export class ArchitectureContextBuilder {
+    context;
+    constructor() {
+        this.context = createEmptyContext();
+    }
+    setSummary(summary) {
+        this.context.summary = { ...this.context.summary, ...summary };
+        return this;
+    }
+    addViolation(violation) {
+        this.context.violations.push(violation);
+        return this;
+    }
+    setViolations(violations) {
+        this.context.violations = violations;
+        return this;
+    }
+    addLayerStats(name, stats) {
+        this.context.layers[name] = { name, ...stats };
+        return this;
+    }
+    setModules(modules) {
+        this.context.modules = modules;
+        return this;
+    }
+    setDependencies(deps) {
+        this.context.dependencies = deps;
+        return this;
+    }
+    setConfig(config) {
+        this.context.config = config;
+        return this;
+    }
+    build() {
+        this.context.timestamp = new Date().toISOString();
+        return this.context;
+    }
+}
+export function createContextBuilder() {
+    return new ArchitectureContextBuilder();
+}

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

@@ -0,0 +1,9 @@
+import type { ArchitectureDefinition } from './definition-schema.js';
+export declare const DC_CONFIG_FILENAME = "dependency-cruiser.js";
+export declare const ANVIL_DIR = ".anvil";
+export declare function getDCConfigPath(workspaceRoot: string): string;
+export declare function dcConfigExists(workspaceRoot: string): boolean;
+export declare function needsRegeneration(workspaceRoot: string, definition: ArchitectureDefinition): Promise<boolean>;
+export declare function writeDCConfig(workspaceRoot: string, definition: ArchitectureDefinition): Promise<string>;
+export declare function generateDCConfig(definition: ArchitectureDefinition): string;
+//# sourceMappingURL=dc-generator.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"dc-generator.d.ts","sourceRoot":"","sources":["../../src/architecture/dc-generator.ts"],"names":[],"mappings":"AAIA,OAAO,KAAK,EAAE,sBAAsB,EAAE,MAAM,wBAAwB,CAAC;AAKrE,eAAO,MAAM,kBAAkB,0BAA0B,CAAC;AAC1D,eAAO,MAAM,SAAS,WAAW,CAAC;AAElC,wBAAgB,eAAe,CAAC,aAAa,EAAE,MAAM,GAAG,MAAM,CAE7D;AAED,wBAAgB,cAAc,CAAC,aAAa,EAAE,MAAM,GAAG,OAAO,CAE7D;AAED,wBAAsB,iBAAiB,CACrC,aAAa,EAAE,MAAM,EACrB,UAAU,EAAE,sBAAsB,GACjC,OAAO,CAAC,OAAO,CAAC,CAYlB;AAOD,wBAAsB,aAAa,CACjC,aAAa,EAAE,MAAM,EACrB,UAAU,EAAE,sBAAsB,GACjC,OAAO,CAAC,MAAM,CAAC,CAUjB;AAED,wBAAgB,gBAAgB,CAAC,UAAU,EAAE,sBAAsB,GAAG,MAAM,CAkC3E"}