@eddacraft/anvil-core 0.1.0

package/dist/crypto/hash.d.ts

@@ -0,0 +1,47 @@
+/**
+ * Hash Generation Utilities
+ *
+ * Provides deterministic hashing functions for APS plans
+ * ensuring data integrity and immutability.
+ */
+/**
+ * Generates a SHA-256 hash of the provided data
+ * @param data - The data to hash (will be canonicalized if object)
+ * @returns Hexadecimal string representation of the hash
+ */
+export declare function generateHash(data: unknown): string;
+/**
+ * Converts an object to a canonical JSON string with sorted keys
+ * This ensures consistent hashing regardless of property order
+ *
+ * @param obj - The object to serialize
+ * @returns Canonical JSON string representation
+ * @throws {TypeError} If obj is `undefined` (not a valid JSON value)
+ */
+export declare function canonicalizeJSON(obj: unknown): string;
+/**
+ * Verifies that the provided hash matches the hash of the data
+ * Uses constant-time comparison to prevent timing attacks
+ * @param data - The data to verify
+ * @param expectedHash - The expected hash value
+ * @returns True if hashes match, false otherwise
+ */
+export declare function verifyHash(data: unknown, expectedHash: string): boolean;
+/**
+ * Generates a unique plan ID in the format 'aps-[16 hex chars]'
+ * @returns A unique plan identifier
+ */
+export declare function generatePlanId(): string;
+/**
+ * Validates that a string is a valid plan ID format
+ * @param id - The ID to validate
+ * @returns True if valid, false otherwise
+ */
+export declare function isValidPlanId(id: string): boolean;
+/**
+ * Validates that a string is a valid SHA-256 hash
+ * @param hash - The hash to validate
+ * @returns True if valid, false otherwise
+ */
+export declare function isValidHash(hash: string): boolean;
+//# sourceMappingURL=hash.d.ts.map

package/dist/crypto/hash.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"hash.d.ts","sourceRoot":"","sources":["../../src/crypto/hash.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAIH;;;;GAIG;AACH,wBAAgB,YAAY,CAAC,IAAI,EAAE,OAAO,GAAG,MAAM,CAQlD;AAED;;;;;;;GAOG;AACH,wBAAgB,gBAAgB,CAAC,GAAG,EAAE,OAAO,GAAG,MAAM,CAgDrD;AAED;;;;;;GAMG;AACH,wBAAgB,UAAU,CAAC,IAAI,EAAE,OAAO,EAAE,YAAY,EAAE,MAAM,GAAG,OAAO,CAUvE;AAED;;;GAGG;AACH,wBAAgB,cAAc,IAAI,MAAM,CAKvC;AAED;;;;GAIG;AACH,wBAAgB,aAAa,CAAC,EAAE,EAAE,MAAM,GAAG,OAAO,CAGjD;AAED;;;;GAIG;AACH,wBAAgB,WAAW,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO,CAEjD"}

package/dist/crypto/hash.js

@@ -0,0 +1,110 @@
+/**
+ * Hash Generation Utilities
+ *
+ * Provides deterministic hashing functions for APS plans
+ * ensuring data integrity and immutability.
+ */
+import { createHash, randomBytes, timingSafeEqual } from 'node:crypto';
+/**
+ * Generates a SHA-256 hash of the provided data
+ * @param data - The data to hash (will be canonicalized if object)
+ * @returns Hexadecimal string representation of the hash
+ */
+export function generateHash(data) {
+    // Convert data to canonical JSON string if it's an object
+    const content = typeof data === 'object' && data !== null ? canonicalizeJSON(data) : String(data);
+    // Create SHA-256 hash
+    const hash = createHash('sha256');
+    hash.update(content, 'utf8');
+    return hash.digest('hex');
+}
+/**
+ * Converts an object to a canonical JSON string with sorted keys
+ * This ensures consistent hashing regardless of property order
+ *
+ * @param obj - The object to serialize
+ * @returns Canonical JSON string representation
+ * @throws {TypeError} If obj is `undefined` (not a valid JSON value)
+ */
+export function canonicalizeJSON(obj) {
+    if (obj === null) {
+        return 'null';
+    }
+    if (obj === undefined) {
+        throw new TypeError('canonicalizeJSON does not accept undefined — it is not a valid JSON value. Use null instead.');
+    }
+    if (typeof obj === 'string') {
+        return JSON.stringify(obj);
+    }
+    if (typeof obj === 'number' || typeof obj === 'boolean') {
+        return String(obj);
+    }
+    if (Array.isArray(obj)) {
+        // Recursively canonicalize array elements
+        const elements = obj.map((element) => canonicalizeJSON(element));
+        return `[${elements.join(',')}]`;
+    }
+    if (obj instanceof Date) {
+        return JSON.stringify(obj.toISOString());
+    }
+    if (typeof obj === 'object') {
+        // Sort object keys and recursively canonicalize values
+        const sortedKeys = Object.keys(obj).sort();
+        const pairs = sortedKeys
+            .map((key) => {
+            const value = obj[key];
+            // Skip undefined values (like JSON.stringify does)
+            if (value === undefined) {
+                return null;
+            }
+            return `${JSON.stringify(key)}:${canonicalizeJSON(value)}`;
+        })
+            .filter((pair) => pair !== null);
+        return `{${pairs.join(',')}}`;
+    }
+    // Fallback for other types
+    return JSON.stringify(obj);
+}
+/**
+ * Verifies that the provided hash matches the hash of the data
+ * Uses constant-time comparison to prevent timing attacks
+ * @param data - The data to verify
+ * @param expectedHash - The expected hash value
+ * @returns True if hashes match, false otherwise
+ */
+export function verifyHash(data, expectedHash) {
+    const actualHash = generateHash(data);
+    // Use constant-time comparison to prevent timing attacks
+    // Both hashes must be the same length for timingSafeEqual
+    if (actualHash.length !== expectedHash.length) {
+        return false;
+    }
+    return timingSafeEqual(Buffer.from(actualHash, 'utf8'), Buffer.from(expectedHash, 'utf8'));
+}
+/**
+ * Generates a unique plan ID in the format 'aps-[16 hex chars]'
+ * @returns A unique plan identifier
+ */
+export function generatePlanId() {
+    // Generate 8 random bytes (16 hex characters) for sufficient entropy
+    const buffer = randomBytes(8);
+    const hexString = buffer.toString('hex');
+    return `aps-${hexString}`;
+}
+/**
+ * Validates that a string is a valid plan ID format
+ * @param id - The ID to validate
+ * @returns True if valid, false otherwise
+ */
+export function isValidPlanId(id) {
+    // Accept both legacy 8-char and new 16-char IDs
+    return /^aps-[a-f0-9]{8}$/.test(id) || /^aps-[a-f0-9]{16}$/.test(id);
+}
+/**
+ * Validates that a string is a valid SHA-256 hash
+ * @param hash - The hash to validate
+ * @returns True if valid, false otherwise
+ */
+export function isValidHash(hash) {
+    return /^[a-f0-9]{64}$/.test(hash);
+}

package/dist/crypto/index.d.ts

@@ -0,0 +1,7 @@
+/**
+ * Crypto Module Public API
+ *
+ * Exports cryptographic utilities for hashing and ID generation.
+ */
+export { generateHash, canonicalizeJSON, verifyHash, generatePlanId, isValidPlanId, isValidHash, } from './hash.js';
+//# sourceMappingURL=index.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/crypto/index.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAEH,OAAO,EACL,YAAY,EACZ,gBAAgB,EAChB,UAAU,EACV,cAAc,EACd,aAAa,EACb,WAAW,GACZ,MAAM,WAAW,CAAC"}

package/dist/crypto/index.js

@@ -0,0 +1,6 @@
+/**
+ * Crypto Module Public API
+ *
+ * Exports cryptographic utilities for hashing and ID generation.
+ */
+export { generateHash, canonicalizeJSON, verifyHash, generatePlanId, isValidPlanId, isValidHash, } from './hash.js';

package/dist/drift/index.d.ts

@@ -0,0 +1,6 @@
+export { SNAPSHOT_SCHEMA_VERSION, SnapshotViolationSchema, type SnapshotViolation, SnapshotAntiPatternSchema, type SnapshotAntiPattern, SnapshotSuppressionSchema, type SnapshotSuppression, SnapshotMetricsSchema, type SnapshotMetrics, AntiPatternBreakdownSchema, type AntiPatternBreakdown, HotspotSchema, type Hotspot, DriftSnapshotSchema, type DriftSnapshot, SnapshotMetadataSchema, type SnapshotMetadata, generateSnapshotFilename, generateNamedSnapshotFilename, parseSnapshotFilename, createEmptySnapshot, validateSnapshot, } from './snapshot-schema.js';
+export { SNAPSHOTS_DIR, ensureSnapshotsDir, saveSnapshot, loadSnapshot, listSnapshots, deleteSnapshot, snapshotExists, getLatestSnapshot, resolveSnapshotName, SnapshotStore, } from './snapshot-storage.js';
+export { type CaptureOptions, type CaptureContext, captureSnapshot, SnapshotCaptureService, createSnapshotCaptureService, } from './snapshot-capture.js';
+export { type ItemChange, type MetricChange, type MetricsComparison, type AntiPatternChange, type SnapshotComparison, compareSnapshots, formatComparisonSummary, } from './snapshot-compare.js';
+export { type ReportOptions, type DriftReport, type ReportSection, generateReport, formatReportAsText, formatReportAsJson, } from './report-generator.js';
+//# sourceMappingURL=index.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/drift/index.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,uBAAuB,EACvB,uBAAuB,EACvB,KAAK,iBAAiB,EACtB,yBAAyB,EACzB,KAAK,mBAAmB,EACxB,yBAAyB,EACzB,KAAK,mBAAmB,EACxB,qBAAqB,EACrB,KAAK,eAAe,EACpB,0BAA0B,EAC1B,KAAK,oBAAoB,EACzB,aAAa,EACb,KAAK,OAAO,EACZ,mBAAmB,EACnB,KAAK,aAAa,EAClB,sBAAsB,EACtB,KAAK,gBAAgB,EACrB,wBAAwB,EACxB,6BAA6B,EAC7B,qBAAqB,EACrB,mBAAmB,EACnB,gBAAgB,GACjB,MAAM,sBAAsB,CAAC;AAE9B,OAAO,EACL,aAAa,EACb,kBAAkB,EAClB,YAAY,EACZ,YAAY,EACZ,aAAa,EACb,cAAc,EACd,cAAc,EACd,iBAAiB,EACjB,mBAAmB,EACnB,aAAa,GACd,MAAM,uBAAuB,CAAC;AAE/B,OAAO,EACL,KAAK,cAAc,EACnB,KAAK,cAAc,EACnB,eAAe,EACf,sBAAsB,EACtB,4BAA4B,GAC7B,MAAM,uBAAuB,CAAC;AAE/B,OAAO,EACL,KAAK,UAAU,EACf,KAAK,YAAY,EACjB,KAAK,iBAAiB,EACtB,KAAK,iBAAiB,EACtB,KAAK,kBAAkB,EACvB,gBAAgB,EAChB,uBAAuB,GACxB,MAAM,uBAAuB,CAAC;AAE/B,OAAO,EACL,KAAK,aAAa,EAClB,KAAK,WAAW,EAChB,KAAK,aAAa,EAClB,cAAc,EACd,kBAAkB,EAClB,kBAAkB,GACnB,MAAM,uBAAuB,CAAC"}

package/dist/drift/index.js

@@ -0,0 +1,5 @@
+export { SNAPSHOT_SCHEMA_VERSION, SnapshotViolationSchema, SnapshotAntiPatternSchema, SnapshotSuppressionSchema, SnapshotMetricsSchema, AntiPatternBreakdownSchema, HotspotSchema, DriftSnapshotSchema, SnapshotMetadataSchema, generateSnapshotFilename, generateNamedSnapshotFilename, parseSnapshotFilename, createEmptySnapshot, validateSnapshot, } from './snapshot-schema.js';
+export { SNAPSHOTS_DIR, ensureSnapshotsDir, saveSnapshot, loadSnapshot, listSnapshots, deleteSnapshot, snapshotExists, getLatestSnapshot, resolveSnapshotName, SnapshotStore, } from './snapshot-storage.js';
+export { captureSnapshot, SnapshotCaptureService, createSnapshotCaptureService, } from './snapshot-capture.js';
+export { compareSnapshots, formatComparisonSummary, } from './snapshot-compare.js';
+export { generateReport, formatReportAsText, formatReportAsJson, } from './report-generator.js';

package/dist/drift/report-generator.d.ts

@@ -0,0 +1,21 @@
+import type { SnapshotComparison } from './snapshot-compare.js';
+export interface ReportOptions {
+    format?: 'text' | 'json';
+    includeDetails?: boolean;
+    maxEdges?: number;
+    maxHotspots?: number;
+}
+export interface DriftReport {
+    summary: string;
+    sections: ReportSection[];
+    recommendation: string;
+    json?: unknown;
+}
+export interface ReportSection {
+    title: string;
+    content: string[];
+}
+export declare function generateReport(comparison: SnapshotComparison, options?: ReportOptions): DriftReport;
+export declare function formatReportAsText(report: DriftReport): string;
+export declare function formatReportAsJson(report: DriftReport): string;
+//# sourceMappingURL=report-generator.d.ts.map

package/dist/drift/report-generator.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"report-generator.d.ts","sourceRoot":"","sources":["../../src/drift/report-generator.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,uBAAuB,CAAC;AAKhE,MAAM,WAAW,aAAa;IAC5B,MAAM,CAAC,EAAE,MAAM,GAAG,MAAM,CAAC;IACzB,cAAc,CAAC,EAAE,OAAO,CAAC;IACzB,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,WAAW,CAAC,EAAE,MAAM,CAAC;CACtB;AAED,MAAM,WAAW,WAAW;IAC1B,OAAO,EAAE,MAAM,CAAC;IAChB,QAAQ,EAAE,aAAa,EAAE,CAAC;IAC1B,cAAc,EAAE,MAAM,CAAC;IACvB,IAAI,CAAC,EAAE,OAAO,CAAC;CAChB;AAED,MAAM,WAAW,aAAa;IAC5B,KAAK,EAAE,MAAM,CAAC;IACd,OAAO,EAAE,MAAM,EAAE,CAAC;CACnB;AAqND,wBAAgB,cAAc,CAC5B,UAAU,EAAE,kBAAkB,EAC9B,OAAO,GAAE,aAAkB,GAC1B,WAAW,CAiCb;AAiDD,wBAAgB,kBAAkB,CAAC,MAAM,EAAE,WAAW,GAAG,MAAM,CAE9D;AAED,wBAAgB,kBAAkB,CAAC,MAAM,EAAE,WAAW,GAAG,MAAM,CAE9D"}

package/dist/drift/report-generator.js

@@ -0,0 +1,240 @@
+import { createDebugger } from '../utils/debug.js';
+const debug = createDebugger('drift');
+const SEPARATOR = '\u2500'.repeat(56);
+function formatDelta(delta) {
+    if (delta > 0)
+        return `+${delta}`;
+    if (delta < 0)
+        return `${delta}`;
+    return '0';
+}
+function formatTrend(trend) {
+    switch (trend) {
+        case 'increasing':
+            return '\u26A0\uFE0F';
+        case 'decreasing':
+            return '\u2705';
+        default:
+            return '\u2796';
+    }
+}
+function formatOverallTrend(trend) {
+    switch (trend) {
+        case 'improving':
+            return 'IMPROVING  \u2705';
+        case 'degrading':
+            return 'INCREASING  \u26A0\uFE0F';
+        default:
+            return 'STABLE  \u2796';
+    }
+}
+function formatDate(isoDate) {
+    return isoDate.split('T')[0];
+}
+function generateHeader(comparison) {
+    const beforeName = comparison.before.name ?? formatDate(comparison.before.created_at);
+    const afterName = comparison.after.name ?? formatDate(comparison.after.created_at);
+    return [
+        `  Drift Report: ${beforeName} \u2192 ${afterName} (${comparison.duration_days} days)`,
+        '',
+        SEPARATOR,
+    ];
+}
+function generateBoundarySection(comparison, options) {
+    const content = [];
+    const metrics = comparison.metrics.boundary_violations;
+    content.push(`  New violations:     ${formatDelta(comparison.violations.added.length)}  (was ${metrics.before}, now ${metrics.after})`);
+    content.push(`  Resolved:           ${formatDelta(-comparison.violations.removed.length)}`);
+    content.push(`  Net change:         ${formatDelta(comparison.net_change.violations)}  ${formatTrend(metrics.trend)}`);
+    if (options.includeDetails && comparison.violations.added.length > 0) {
+        content.push('');
+        content.push('  New edges detected:');
+        const maxEdges = options.maxEdges ?? 5;
+        const edgesToShow = comparison.violations.added.slice(0, maxEdges);
+        for (const v of edgesToShow) {
+            const rule = v.rule ?? `${v.from_layer}\u2192${v.to_layer}`;
+            content.push(`  \u2022 ${v.from_file} \u2192 ${v.to_file} (${rule})`);
+        }
+        if (comparison.violations.added.length > maxEdges) {
+            content.push(`  ... and ${comparison.violations.added.length - maxEdges} more`);
+        }
+    }
+    return { title: 'ARCHITECTURE BOUNDARIES', content };
+}
+function generateAntiPatternSection(comparison, options) {
+    const content = [];
+    const metrics = comparison.metrics.antipattern_count;
+    content.push(`  New introductions:  ${formatDelta(comparison.antipatterns.added.length)}`);
+    content.push(`  Resolved:           ${formatDelta(-comparison.antipatterns.removed.length)}`);
+    content.push(`  Net change:         ${formatDelta(comparison.net_change.antipatterns)}  ${formatTrend(metrics.trend)}`);
+    if (comparison.antipattern_changes.length > 0) {
+        content.push('');
+        content.push('  By type:');
+        for (const change of comparison.antipattern_changes.slice(0, 5)) {
+            content.push(`  \u2022 ${change.id}:     ${formatDelta(change.delta)}`);
+        }
+    }
+    if (options.includeDetails) {
+        const hotspots = findAntiPatternHotspots(comparison);
+        if (hotspots.length > 0) {
+            content.push('');
+            content.push('  Hotspots:');
+            const maxHotspots = options.maxHotspots ?? 3;
+            for (const hs of hotspots.slice(0, maxHotspots)) {
+                content.push(`  \u2022 ${hs.path} \u2014 ${hs.count} new violations`);
+            }
+        }
+    }
+    return { title: 'ANTI-PATTERNS', content };
+}
+function findAntiPatternHotspots(comparison) {
+    const dirCounts = new Map();
+    for (const ap of comparison.antipatterns.added) {
+        const parts = ap.file.split('/');
+        const dir = parts.slice(0, -1).join('/') || '.';
+        dirCounts.set(dir, (dirCounts.get(dir) ?? 0) + 1);
+    }
+    return Array.from(dirCounts.entries())
+        .filter(([_, count]) => count > 1)
+        .sort((a, b) => b[1] - a[1])
+        .map(([path, count]) => ({ path, count }));
+}
+function generateSuppressionSection(comparison) {
+    const content = [];
+    const expiredMetrics = comparison.metrics.expired_suppressions;
+    content.push(`  New suppressions:   ${formatDelta(comparison.suppressions.added.length)}`);
+    content.push(`  Expired:            ${formatDelta(expiredMetrics.delta)}`);
+    content.push(`  Net change:         ${formatDelta(comparison.net_change.suppressions)}`);
+    const oldestUnexpired = findOldestUnexpiredSuppression(comparison);
+    if (oldestUnexpired) {
+        content.push('');
+        content.push(`  Oldest unexpired: ${oldestUnexpired.age} days (${oldestUnexpired.file})`);
+    }
+    return { title: 'SUPPRESSIONS', content };
+}
+function findOldestUnexpiredSuppression(comparison) {
+    const activeSuppressions = comparison.suppressions.unchanged.filter((s) => !s.is_expired);
+    if (activeSuppressions.length === 0)
+        return null;
+    return {
+        age: comparison.duration_days,
+        file: activeSuppressions[0].file,
+    };
+}
+function generateSummarySection(comparison) {
+    const content = [];
+    content.push(`  Overall drift:  ${formatOverallTrend(comparison.overall_trend)}`);
+    return { title: 'SUMMARY', content };
+}
+function generateRecommendation(comparison) {
+    if (comparison.overall_trend === 'degrading') {
+        if (comparison.violations.added.length > 0) {
+            const topViolationDir = getMostAffectedDirectory(comparison.violations.added);
+            return `Review new violations in ${topViolationDir}`;
+        }
+        if (comparison.antipatterns.added.length > 0) {
+            const topPattern = comparison.antipattern_changes[0]?.id ?? 'anti-patterns';
+            return `Address increasing ${topPattern} occurrences`;
+        }
+    }
+    if (comparison.overall_trend === 'improving') {
+        return 'Good progress! Continue addressing remaining issues.';
+    }
+    return 'Architecture is stable. Monitor for new changes.';
+}
+function getMostAffectedDirectory(violations) {
+    const dirCounts = new Map();
+    for (const v of violations) {
+        const parts = v.from_file.split('/');
+        const dir = parts.slice(0, 2).join('/') || '.';
+        dirCounts.set(dir, (dirCounts.get(dir) ?? 0) + 1);
+    }
+    let maxDir = '.';
+    let maxCount = 0;
+    for (const [dir, count] of dirCounts) {
+        if (count > maxCount) {
+            maxCount = count;
+            maxDir = dir;
+        }
+    }
+    return maxDir + '/';
+}
+export function generateReport(comparison, options = {}) {
+    debug('generating drift report', {
+        format: options.format,
+        includeDetails: options.includeDetails,
+        trend: comparison.overall_trend,
+    });
+    const { includeDetails = true } = options;
+    const effectiveOptions = { ...options, includeDetails };
+    const sections = [
+        generateBoundarySection(comparison, effectiveOptions),
+        generateAntiPatternSection(comparison, effectiveOptions),
+        generateSuppressionSection(comparison),
+        generateSummarySection(comparison),
+    ];
+    const recommendation = generateRecommendation(comparison);
+    const header = generateHeader(comparison);
+    const sectionTexts = sections.map((s) => {
+        return [`  ${s.title}`, '', ...s.content, '', SEPARATOR].join('\n');
+    });
+    const summary = [...header, '', ...sectionTexts, `  Recommendation: ${recommendation}`, ''].join('\n');
+    return {
+        summary,
+        sections,
+        recommendation,
+        json: options.format === 'json' ? generateJsonReport(comparison) : undefined,
+    };
+}
+function generateJsonReport(comparison) {
+    return {
+        before: comparison.before,
+        after: comparison.after,
+        duration_days: comparison.duration_days,
+        metrics: {
+            boundary_violations: {
+                before: comparison.metrics.boundary_violations.before,
+                after: comparison.metrics.boundary_violations.after,
+                delta: comparison.metrics.boundary_violations.delta,
+            },
+            antipattern_count: {
+                before: comparison.metrics.antipattern_count.before,
+                after: comparison.metrics.antipattern_count.after,
+                delta: comparison.metrics.antipattern_count.delta,
+            },
+            suppression_count: {
+                before: comparison.metrics.suppression_count.before,
+                after: comparison.metrics.suppression_count.after,
+                delta: comparison.metrics.suppression_count.delta,
+            },
+        },
+        net_change: comparison.net_change,
+        changes: {
+            violations: {
+                added: comparison.violations.added.length,
+                removed: comparison.violations.removed.length,
+                unchanged: comparison.violations.unchanged.length,
+            },
+            antipatterns: {
+                added: comparison.antipatterns.added.length,
+                removed: comparison.antipatterns.removed.length,
+                unchanged: comparison.antipatterns.unchanged.length,
+            },
+            suppressions: {
+                added: comparison.suppressions.added.length,
+                removed: comparison.suppressions.removed.length,
+                unchanged: comparison.suppressions.unchanged.length,
+            },
+        },
+        antipattern_changes: comparison.antipattern_changes,
+        overall_trend: comparison.overall_trend,
+        added_violations: comparison.violations.added,
+        added_antipatterns: comparison.antipatterns.added,
+    };
+}
+export function formatReportAsText(report) {
+    return report.summary;
+}
+export function formatReportAsJson(report) {
+    return JSON.stringify(report.json ?? {}, null, 2);
+}

package/dist/drift/snapshot-capture.d.ts

@@ -0,0 +1,26 @@
+import { type DriftSnapshot } from './snapshot-schema.js';
+import { type ArchitectureBaseline } from '../architecture/index.js';
+import { type ScanResult } from '../antipattern/index.js';
+import { type FileSuppressions } from '../suppression/index.js';
+export interface CaptureOptions {
+    name?: string;
+    includeOptInPatterns?: boolean;
+    sourcePatterns?: string[];
+}
+export interface CaptureContext {
+    workspaceRoot: string;
+    files: string[];
+    baseline: ArchitectureBaseline | null;
+    scanResults: ScanResult[];
+    suppressions: FileSuppressions[];
+    gitRef?: string;
+}
+export declare function captureSnapshot(context: CaptureContext, options?: CaptureOptions): Promise<DriftSnapshot>;
+export declare class SnapshotCaptureService {
+    private workspaceRoot;
+    constructor(workspaceRoot: string);
+    capture(files: string[], options?: CaptureOptions): Promise<DriftSnapshot>;
+    captureWithContext(context: Partial<CaptureContext>, options?: CaptureOptions): Promise<DriftSnapshot>;
+}
+export declare function createSnapshotCaptureService(workspaceRoot: string): SnapshotCaptureService;
+//# sourceMappingURL=snapshot-capture.d.ts.map

package/dist/drift/snapshot-capture.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"snapshot-capture.d.ts","sourceRoot":"","sources":["../../src/drift/snapshot-capture.ts"],"names":[],"mappings":"AAKA,OAAO,EACL,KAAK,aAAa,EAQnB,MAAM,sBAAsB,CAAC;AAC9B,OAAO,EAEL,KAAK,oBAAoB,EAE1B,MAAM,0BAA0B,CAAC;AAClC,OAAO,EAAa,KAAK,UAAU,EAAE,MAAM,yBAAyB,CAAC;AACrE,OAAO,EAAsB,KAAK,gBAAgB,EAAE,MAAM,yBAAyB,CAAC;AAMpF,MAAM,WAAW,cAAc;IAC7B,IAAI,CAAC,EAAE,MAAM,CAAC;IACd,oBAAoB,CAAC,EAAE,OAAO,CAAC;IAC/B,cAAc,CAAC,EAAE,MAAM,EAAE,CAAC;CAC3B;AAED,MAAM,WAAW,cAAc;IAC7B,aAAa,EAAE,MAAM,CAAC;IACtB,KAAK,EAAE,MAAM,EAAE,CAAC;IAChB,QAAQ,EAAE,oBAAoB,GAAG,IAAI,CAAC;IACtC,WAAW,EAAE,UAAU,EAAE,CAAC;IAC1B,YAAY,EAAE,gBAAgB,EAAE,CAAC;IACjC,MAAM,CAAC,EAAE,MAAM,CAAC;CACjB;AA0ID,wBAAsB,eAAe,CACnC,OAAO,EAAE,cAAc,EACvB,OAAO,GAAE,cAAmB,GAC3B,OAAO,CAAC,aAAa,CAAC,CA0BxB;AAED,qBAAa,sBAAsB;IACjC,OAAO,CAAC,aAAa,CAAS;gBAElB,aAAa,EAAE,MAAM;IAI3B,OAAO,CAAC,KAAK,EAAE,MAAM,EAAE,EAAE,OAAO,GAAE,cAAmB,GAAG,OAAO,CAAC,aAAa,CAAC;IAwC9E,kBAAkB,CACtB,OAAO,EAAE,OAAO,CAAC,cAAc,CAAC,EAChC,OAAO,GAAE,cAAmB,GAC3B,OAAO,CAAC,aAAa,CAAC;CAY1B;AAED,wBAAgB,4BAA4B,CAAC,aAAa,EAAE,MAAM,GAAG,sBAAsB,CAE1F"}