@eddacraft/anvil-core 0.1.0

package/dist/drift/snapshot-capture.js

@@ -0,0 +1,195 @@
+import * as fs from 'node:fs/promises';
+import * as path from 'node:path';
+import { execFile } from 'node:child_process';
+import { promisify } from 'node:util';
+import { createDebugger } from '../utils/debug.js';
+import { SNAPSHOT_SCHEMA_VERSION, } from './snapshot-schema.js';
+import { loadBaseline, } from '../architecture/index.js';
+import { scanFiles } from '../antipattern/index.js';
+import { SuppressionService } from '../suppression/index.js';
+import { generateHash } from '../crypto/index.js';
+const debug = createDebugger('drift');
+const execFileAsync = promisify(execFile);
+async function getGitRef(workspaceRoot) {
+    try {
+        const { stdout } = await execFileAsync('git', ['rev-parse', 'HEAD'], { cwd: workspaceRoot });
+        return stdout.trim();
+    }
+    catch (err) {
+        debug('failed to get git ref for workspace', err);
+        return undefined;
+    }
+}
+function baselineViolationToSnapshot(violation) {
+    return {
+        id: violation.id,
+        type: 'boundary',
+        from_file: violation.from_file,
+        to_file: violation.to_file,
+        from_layer: violation.from_layer,
+        to_layer: violation.to_layer,
+        line: violation.import_line,
+        rule: violation.rule,
+    };
+}
+function extractAntiPatterns(scanResults) {
+    const antipatterns = [];
+    for (const result of scanResults) {
+        for (const warning of result.warnings) {
+            if (warning.category !== 'anti-pattern')
+                continue;
+            if (warning.suppressed)
+                continue;
+            antipatterns.push({
+                id: warning.id,
+                file: warning.location.file,
+                line: warning.location.line,
+                pattern: warning.pattern ?? warning.id,
+                severity: warning.severity,
+            });
+        }
+    }
+    return antipatterns;
+}
+function extractSuppressions(fileSuppressions, now = new Date()) {
+    const suppressions = [];
+    for (const { file, suppressions: fileSupprs } of fileSuppressions) {
+        for (const s of fileSupprs) {
+            const isExpired = s.expiresAt ? s.expiresAt < now : false;
+            suppressions.push({
+                id: `${file}:${s.line}:${s.warningId}`,
+                pattern_id: s.warningId,
+                file,
+                line: s.line,
+                reason: s.reason,
+                scope: s.scope,
+                expires_at: s.expiresAt?.toISOString(),
+                is_expired: isExpired,
+            });
+        }
+    }
+    return suppressions;
+}
+function calculateAntiPatternBreakdown(antipatterns) {
+    const breakdown = {};
+    for (const ap of antipatterns) {
+        breakdown[ap.id] = (breakdown[ap.id] ?? 0) + 1;
+    }
+    return breakdown;
+}
+function calculateHotspots(violations, antipatterns, topN = 5) {
+    const pathCounts = new Map();
+    for (const v of violations) {
+        const dir = path.dirname(v.from_file);
+        const existing = pathCounts.get(dir) ?? { count: 0, types: new Set() };
+        existing.count++;
+        existing.types.add('boundary');
+        pathCounts.set(dir, existing);
+    }
+    for (const ap of antipatterns) {
+        const dir = path.dirname(ap.file);
+        const existing = pathCounts.get(dir) ?? { count: 0, types: new Set() };
+        existing.count++;
+        existing.types.add(ap.id);
+        pathCounts.set(dir, existing);
+    }
+    return Array.from(pathCounts.entries())
+        .filter(([_, data]) => data.count > 1)
+        .sort((a, b) => b[1].count - a[1].count)
+        .slice(0, topN)
+        .map(([dirPath, data]) => ({
+        path: dirPath,
+        violation_count: data.count,
+        types: Array.from(data.types),
+    }));
+}
+function calculateMetrics(violations, antipatterns, suppressions, filesAnalysed) {
+    const expiredSuppressions = suppressions.filter((s) => s.is_expired).length;
+    return {
+        boundary_violations: violations.length,
+        antipattern_count: antipatterns.length,
+        suppression_count: suppressions.filter((s) => !s.is_expired).length,
+        expired_suppressions: expiredSuppressions,
+        files_analysed: filesAnalysed,
+    };
+}
+function generateBaselineHash(baseline) {
+    if (!baseline)
+        return undefined;
+    return generateHash(JSON.stringify(baseline));
+}
+export async function captureSnapshot(context, options = {}) {
+    const { files, baseline, scanResults, suppressions, gitRef } = context;
+    const violations = baseline
+        ? baseline.baseline_snapshot.violations.map(baselineViolationToSnapshot)
+        : [];
+    const antipatterns = extractAntiPatterns(scanResults);
+    const snapshotSuppressions = extractSuppressions(suppressions);
+    const metrics = calculateMetrics(violations, antipatterns, snapshotSuppressions, files.length);
+    const breakdown = calculateAntiPatternBreakdown(antipatterns);
+    const hotspots = calculateHotspots(violations, antipatterns);
+    return {
+        schema_version: SNAPSHOT_SCHEMA_VERSION,
+        created_at: new Date().toISOString(),
+        name: options.name,
+        metrics,
+        antipattern_breakdown: Object.keys(breakdown).length > 0 ? breakdown : undefined,
+        hotspots: hotspots.length > 0 ? hotspots : undefined,
+        violations,
+        antipatterns,
+        suppressions: snapshotSuppressions,
+        baseline_hash: generateBaselineHash(baseline),
+        git_ref: gitRef,
+    };
+}
+export class SnapshotCaptureService {
+    workspaceRoot;
+    constructor(workspaceRoot) {
+        this.workspaceRoot = workspaceRoot;
+    }
+    async capture(files, options = {}) {
+        const baseline = loadBaseline(this.workspaceRoot);
+        const filesWithContent = await Promise.all(files.map(async (filePath) => {
+            const fullPath = path.isAbsolute(filePath)
+                ? filePath
+                : path.join(this.workspaceRoot, filePath);
+            try {
+                const content = await fs.readFile(fullPath, 'utf-8');
+                return { path: filePath, content };
+            }
+            catch (err) {
+                debug('failed to read file for snapshot capture: %s', err);
+                return null;
+            }
+        }));
+        const validFiles = filesWithContent.filter((f) => f !== null);
+        const scanResults = scanFiles(validFiles, { includeOptIn: options.includeOptInPatterns });
+        const suppressionService = new SuppressionService(this.workspaceRoot);
+        await suppressionService.initialize();
+        const suppressions = await suppressionService.processFiles(files);
+        const gitRef = await getGitRef(this.workspaceRoot);
+        const context = {
+            workspaceRoot: this.workspaceRoot,
+            files,
+            baseline,
+            scanResults,
+            suppressions,
+            gitRef,
+        };
+        return captureSnapshot(context, options);
+    }
+    async captureWithContext(context, options = {}) {
+        const fullContext = {
+            workspaceRoot: context.workspaceRoot ?? this.workspaceRoot,
+            files: context.files ?? [],
+            baseline: context.baseline ?? null,
+            scanResults: context.scanResults ?? [],
+            suppressions: context.suppressions ?? [],
+            gitRef: context.gitRef,
+        };
+        return captureSnapshot(fullContext, options);
+    }
+}
+export function createSnapshotCaptureService(workspaceRoot) {
+    return new SnapshotCaptureService(workspaceRoot);
+}

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

@@ -0,0 +1,50 @@
+import type { DriftSnapshot, SnapshotViolation, SnapshotAntiPattern, SnapshotSuppression } from './snapshot-schema.js';
+export interface ItemChange<T> {
+    added: T[];
+    removed: T[];
+    unchanged: T[];
+}
+export interface MetricChange {
+    before: number;
+    after: number;
+    delta: number;
+    trend: 'increasing' | 'decreasing' | 'stable';
+}
+export interface MetricsComparison {
+    boundary_violations: MetricChange;
+    antipattern_count: MetricChange;
+    suppression_count: MetricChange;
+    expired_suppressions: MetricChange;
+    files_analysed: MetricChange;
+}
+export interface AntiPatternChange {
+    id: string;
+    before: number;
+    after: number;
+    delta: number;
+}
+export interface SnapshotComparison {
+    before: {
+        name?: string;
+        created_at: string;
+    };
+    after: {
+        name?: string;
+        created_at: string;
+    };
+    duration_days: number;
+    metrics: MetricsComparison;
+    net_change: {
+        violations: number;
+        antipatterns: number;
+        suppressions: number;
+    };
+    violations: ItemChange<SnapshotViolation>;
+    antipatterns: ItemChange<SnapshotAntiPattern>;
+    suppressions: ItemChange<SnapshotSuppression>;
+    antipattern_changes: AntiPatternChange[];
+    overall_trend: 'improving' | 'stable' | 'degrading';
+}
+export declare function compareSnapshots(before: DriftSnapshot, after: DriftSnapshot): SnapshotComparison;
+export declare function formatComparisonSummary(comparison: SnapshotComparison): string;
+//# sourceMappingURL=snapshot-compare.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"snapshot-compare.d.ts","sourceRoot":"","sources":["../../src/drift/snapshot-compare.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EACV,aAAa,EACb,iBAAiB,EACjB,mBAAmB,EACnB,mBAAmB,EAEpB,MAAM,sBAAsB,CAAC;AAK9B,MAAM,WAAW,UAAU,CAAC,CAAC;IAC3B,KAAK,EAAE,CAAC,EAAE,CAAC;IACX,OAAO,EAAE,CAAC,EAAE,CAAC;IACb,SAAS,EAAE,CAAC,EAAE,CAAC;CAChB;AAED,MAAM,WAAW,YAAY;IAC3B,MAAM,EAAE,MAAM,CAAC;IACf,KAAK,EAAE,MAAM,CAAC;IACd,KAAK,EAAE,MAAM,CAAC;IACd,KAAK,EAAE,YAAY,GAAG,YAAY,GAAG,QAAQ,CAAC;CAC/C;AAED,MAAM,WAAW,iBAAiB;IAChC,mBAAmB,EAAE,YAAY,CAAC;IAClC,iBAAiB,EAAE,YAAY,CAAC;IAChC,iBAAiB,EAAE,YAAY,CAAC;IAChC,oBAAoB,EAAE,YAAY,CAAC;IACnC,cAAc,EAAE,YAAY,CAAC;CAC9B;AAED,MAAM,WAAW,iBAAiB;IAChC,EAAE,EAAE,MAAM,CAAC;IACX,MAAM,EAAE,MAAM,CAAC;IACf,KAAK,EAAE,MAAM,CAAC;IACd,KAAK,EAAE,MAAM,CAAC;CACf;AAED,MAAM,WAAW,kBAAkB;IACjC,MAAM,EAAE;QACN,IAAI,CAAC,EAAE,MAAM,CAAC;QACd,UAAU,EAAE,MAAM,CAAC;KACpB,CAAC;IACF,KAAK,EAAE;QACL,IAAI,CAAC,EAAE,MAAM,CAAC;QACd,UAAU,EAAE,MAAM,CAAC;KACpB,CAAC;IACF,aAAa,EAAE,MAAM,CAAC;IAEtB,OAAO,EAAE,iBAAiB,CAAC;IAC3B,UAAU,EAAE;QACV,UAAU,EAAE,MAAM,CAAC;QACnB,YAAY,EAAE,MAAM,CAAC;QACrB,YAAY,EAAE,MAAM,CAAC;KACtB,CAAC;IAEF,UAAU,EAAE,UAAU,CAAC,iBAAiB,CAAC,CAAC;IAC1C,YAAY,EAAE,UAAU,CAAC,mBAAmB,CAAC,CAAC;IAC9C,YAAY,EAAE,UAAU,CAAC,mBAAmB,CAAC,CAAC;IAE9C,mBAAmB,EAAE,iBAAiB,EAAE,CAAC;IAEzC,aAAa,EAAE,WAAW,GAAG,QAAQ,GAAG,WAAW,CAAC;CACrD;AA0HD,wBAAgB,gBAAgB,CAAC,MAAM,EAAE,aAAa,EAAE,KAAK,EAAE,aAAa,GAAG,kBAAkB,CAqChG;AAED,wBAAgB,uBAAuB,CAAC,UAAU,EAAE,kBAAkB,GAAG,MAAM,CAoC9E"}

package/dist/drift/snapshot-compare.js

@@ -0,0 +1,142 @@
+import { createDebugger } from '../utils/debug.js';
+const debug = createDebugger('drift');
+function calculateMetricChange(before, after) {
+    const delta = after - before;
+    let trend;
+    if (delta > 0) {
+        trend = 'increasing';
+    }
+    else if (delta < 0) {
+        trend = 'decreasing';
+    }
+    else {
+        trend = 'stable';
+    }
+    return { before, after, delta, trend };
+}
+function compareMetrics(before, after) {
+    return {
+        boundary_violations: calculateMetricChange(before.boundary_violations, after.boundary_violations),
+        antipattern_count: calculateMetricChange(before.antipattern_count, after.antipattern_count),
+        suppression_count: calculateMetricChange(before.suppression_count, after.suppression_count),
+        expired_suppressions: calculateMetricChange(before.expired_suppressions, after.expired_suppressions),
+        files_analysed: calculateMetricChange(before.files_analysed, after.files_analysed),
+    };
+}
+function compareViolations(before, after) {
+    const beforeIds = new Set(before.map((v) => v.id));
+    const afterIds = new Set(after.map((v) => v.id));
+    const added = after.filter((v) => !beforeIds.has(v.id));
+    const removed = before.filter((v) => !afterIds.has(v.id));
+    const unchanged = after.filter((v) => beforeIds.has(v.id));
+    return { added, removed, unchanged };
+}
+function compareAntiPatterns(before, after) {
+    const fingerprint = (ap) => `${ap.file}:${ap.line}:${ap.id}`;
+    const beforeFingerprints = new Set(before.map(fingerprint));
+    const afterFingerprints = new Set(after.map(fingerprint));
+    const added = after.filter((ap) => !beforeFingerprints.has(fingerprint(ap)));
+    const removed = before.filter((ap) => !afterFingerprints.has(fingerprint(ap)));
+    const unchanged = after.filter((ap) => beforeFingerprints.has(fingerprint(ap)));
+    return { added, removed, unchanged };
+}
+function compareSuppressions(before, after) {
+    const beforeIds = new Set(before.map((s) => s.id));
+    const afterIds = new Set(after.map((s) => s.id));
+    const added = after.filter((s) => !beforeIds.has(s.id));
+    const removed = before.filter((s) => !afterIds.has(s.id));
+    const unchanged = after.filter((s) => beforeIds.has(s.id));
+    return { added, removed, unchanged };
+}
+function calculateAntiPatternChanges(before, after) {
+    const beforeBreakdown = before.antipattern_breakdown ?? {};
+    const afterBreakdown = after.antipattern_breakdown ?? {};
+    const allIds = new Set([...Object.keys(beforeBreakdown), ...Object.keys(afterBreakdown)]);
+    const changes = [];
+    for (const id of allIds) {
+        const beforeCount = beforeBreakdown[id] ?? 0;
+        const afterCount = afterBreakdown[id] ?? 0;
+        const delta = afterCount - beforeCount;
+        if (delta !== 0) {
+            changes.push({ id, before: beforeCount, after: afterCount, delta });
+        }
+    }
+    return changes.sort((a, b) => Math.abs(b.delta) - Math.abs(a.delta));
+}
+function calculateDurationDays(before, after) {
+    const beforeDate = new Date(before);
+    const afterDate = new Date(after);
+    const diffMs = afterDate.getTime() - beforeDate.getTime();
+    return Math.round(diffMs / (1000 * 60 * 60 * 24));
+}
+function determineOverallTrend(metrics) {
+    const violationsTrend = metrics.boundary_violations.delta;
+    const antipatternsTrend = metrics.antipattern_count.delta;
+    const totalChange = violationsTrend + antipatternsTrend;
+    if (totalChange < 0) {
+        return 'improving';
+    }
+    else if (totalChange > 0) {
+        return 'degrading';
+    }
+    return 'stable';
+}
+export function compareSnapshots(before, after) {
+    debug('comparing snapshots', {
+        before: before.name ?? before.created_at,
+        after: after.name ?? after.created_at,
+    });
+    const metrics = compareMetrics(before.metrics, after.metrics);
+    const violations = compareViolations(before.violations, after.violations);
+    const antipatterns = compareAntiPatterns(before.antipatterns, after.antipatterns);
+    const suppressions = compareSuppressions(before.suppressions, after.suppressions);
+    const antipatternChanges = calculateAntiPatternChanges(before, after);
+    return {
+        before: {
+            name: before.name,
+            created_at: before.created_at,
+        },
+        after: {
+            name: after.name,
+            created_at: after.created_at,
+        },
+        duration_days: calculateDurationDays(before.created_at, after.created_at),
+        metrics,
+        net_change: {
+            violations: violations.added.length - violations.removed.length,
+            antipatterns: antipatterns.added.length - antipatterns.removed.length,
+            suppressions: suppressions.added.length - suppressions.removed.length,
+        },
+        violations,
+        antipatterns,
+        suppressions,
+        antipattern_changes: antipatternChanges,
+        overall_trend: determineOverallTrend(metrics),
+    };
+}
+export function formatComparisonSummary(comparison) {
+    const lines = [];
+    const beforeName = comparison.before.name ?? comparison.before.created_at.split('T')[0];
+    const afterName = comparison.after.name ?? comparison.after.created_at.split('T')[0];
+    lines.push(`Comparing: ${beforeName} → ${afterName} (${comparison.duration_days} days)`);
+    lines.push('');
+    lines.push('Metrics:');
+    lines.push(`  Boundary violations: ${comparison.metrics.boundary_violations.before} → ${comparison.metrics.boundary_violations.after} (${formatDelta(comparison.metrics.boundary_violations.delta)})`);
+    lines.push(`  Anti-patterns: ${comparison.metrics.antipattern_count.before} → ${comparison.metrics.antipattern_count.after} (${formatDelta(comparison.metrics.antipattern_count.delta)})`);
+    lines.push(`  Suppressions: ${comparison.metrics.suppression_count.before} → ${comparison.metrics.suppression_count.after} (${formatDelta(comparison.metrics.suppression_count.delta)})`);
+    lines.push('');
+    lines.push('Changes:');
+    lines.push(`  Violations: +${comparison.violations.added.length} added, -${comparison.violations.removed.length} removed`);
+    lines.push(`  Anti-patterns: +${comparison.antipatterns.added.length} added, -${comparison.antipatterns.removed.length} removed`);
+    lines.push(`  Suppressions: +${comparison.suppressions.added.length} added, -${comparison.suppressions.removed.length} removed`);
+    lines.push('');
+    lines.push(`Overall trend: ${comparison.overall_trend.toUpperCase()}`);
+    return lines.join('\n');
+}
+function formatDelta(delta) {
+    if (delta > 0)
+        return `+${delta}`;
+    if (delta < 0)
+        return `${delta}`;
+    return '0';
+}

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

@@ -0,0 +1,197 @@
+/**
+ * Drift snapshot schema
+ *
+ * Defines the structure for point-in-time drift snapshots used to track
+ * architecture evolution over time. Follows Zod-first approach per ADR-0001.
+ */
+import { z } from 'zod';
+export declare const SNAPSHOT_SCHEMA_VERSION = "1.0.0";
+/**
+ * A recorded boundary violation in the snapshot
+ */
+export declare const SnapshotViolationSchema: z.ZodObject<{
+    id: z.ZodString;
+    type: z.ZodEnum<{
+        boundary: "boundary";
+        architecture: "architecture";
+    }>;
+    from_file: z.ZodString;
+    to_file: z.ZodString;
+    from_layer: z.ZodNullable<z.ZodString>;
+    to_layer: z.ZodNullable<z.ZodString>;
+    line: z.ZodNumber;
+    rule: z.ZodOptional<z.ZodString>;
+    message: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+export type SnapshotViolation = z.infer<typeof SnapshotViolationSchema>;
+/**
+ * A recorded anti-pattern occurrence in the snapshot
+ */
+export declare const SnapshotAntiPatternSchema: z.ZodObject<{
+    id: z.ZodString;
+    file: z.ZodString;
+    line: z.ZodNumber;
+    pattern: z.ZodString;
+    severity: z.ZodEnum<{
+        warning: "warning";
+        error: "error";
+        info: "info";
+    }>;
+}, z.core.$strip>;
+export type SnapshotAntiPattern = z.infer<typeof SnapshotAntiPatternSchema>;
+/**
+ * A recorded suppression in the snapshot
+ */
+export declare const SnapshotSuppressionSchema: z.ZodObject<{
+    id: z.ZodString;
+    pattern_id: z.ZodString;
+    file: z.ZodString;
+    line: z.ZodNumber;
+    reason: z.ZodString;
+    scope: z.ZodEnum<{
+        file: "file";
+        line: "line";
+        statement: "statement";
+        import: "import";
+    }>;
+    expires_at: z.ZodOptional<z.ZodString>;
+    is_expired: z.ZodOptional<z.ZodBoolean>;
+}, z.core.$strip>;
+export type SnapshotSuppression = z.infer<typeof SnapshotSuppressionSchema>;
+/**
+ * Aggregate metrics for quick comparison
+ */
+export declare const SnapshotMetricsSchema: z.ZodObject<{
+    boundary_violations: z.ZodNumber;
+    antipattern_count: z.ZodNumber;
+    suppression_count: z.ZodNumber;
+    expired_suppressions: z.ZodNumber;
+    files_analysed: z.ZodNumber;
+}, z.core.$strip>;
+export type SnapshotMetrics = z.infer<typeof SnapshotMetricsSchema>;
+/**
+ * Breakdown of anti-patterns by type
+ */
+export declare const AntiPatternBreakdownSchema: z.ZodRecord<z.ZodString, z.ZodNumber>;
+export type AntiPatternBreakdown = z.infer<typeof AntiPatternBreakdownSchema>;
+/**
+ * A file or directory with high violation concentration
+ */
+export declare const HotspotSchema: z.ZodObject<{
+    path: z.ZodString;
+    violation_count: z.ZodNumber;
+    types: z.ZodArray<z.ZodString>;
+}, z.core.$strip>;
+export type Hotspot = z.infer<typeof HotspotSchema>;
+/**
+ * Complete drift snapshot for point-in-time state capture
+ */
+export declare const DriftSnapshotSchema: z.ZodObject<{
+    schema_version: z.ZodString;
+    created_at: z.ZodString;
+    name: z.ZodOptional<z.ZodString>;
+    metrics: z.ZodObject<{
+        boundary_violations: z.ZodNumber;
+        antipattern_count: z.ZodNumber;
+        suppression_count: z.ZodNumber;
+        expired_suppressions: z.ZodNumber;
+        files_analysed: z.ZodNumber;
+    }, z.core.$strip>;
+    antipattern_breakdown: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodNumber>>;
+    hotspots: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        path: z.ZodString;
+        violation_count: z.ZodNumber;
+        types: z.ZodArray<z.ZodString>;
+    }, z.core.$strip>>>;
+    violations: z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        type: z.ZodEnum<{
+            boundary: "boundary";
+            architecture: "architecture";
+        }>;
+        from_file: z.ZodString;
+        to_file: z.ZodString;
+        from_layer: z.ZodNullable<z.ZodString>;
+        to_layer: z.ZodNullable<z.ZodString>;
+        line: z.ZodNumber;
+        rule: z.ZodOptional<z.ZodString>;
+        message: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>>;
+    antipatterns: z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        file: z.ZodString;
+        line: z.ZodNumber;
+        pattern: z.ZodString;
+        severity: z.ZodEnum<{
+            warning: "warning";
+            error: "error";
+            info: "info";
+        }>;
+    }, z.core.$strip>>;
+    suppressions: z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        pattern_id: z.ZodString;
+        file: z.ZodString;
+        line: z.ZodNumber;
+        reason: z.ZodString;
+        scope: z.ZodEnum<{
+            file: "file";
+            line: "line";
+            statement: "statement";
+            import: "import";
+        }>;
+        expires_at: z.ZodOptional<z.ZodString>;
+        is_expired: z.ZodOptional<z.ZodBoolean>;
+    }, z.core.$strip>>;
+    baseline_hash: z.ZodOptional<z.ZodString>;
+    git_ref: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+export type DriftSnapshot = z.infer<typeof DriftSnapshotSchema>;
+/**
+ * Metadata for listing snapshots
+ */
+export declare const SnapshotMetadataSchema: z.ZodObject<{
+    filename: z.ZodString;
+    name: z.ZodOptional<z.ZodString>;
+    created_at: z.ZodString;
+    metrics: z.ZodObject<{
+        boundary_violations: z.ZodNumber;
+        antipattern_count: z.ZodNumber;
+        suppression_count: z.ZodNumber;
+        expired_suppressions: z.ZodNumber;
+        files_analysed: z.ZodNumber;
+    }, z.core.$strip>;
+}, z.core.$strip>;
+export type SnapshotMetadata = z.infer<typeof SnapshotMetadataSchema>;
+/**
+ * Generate a snapshot filename from timestamp
+ */
+export declare function generateSnapshotFilename(date?: Date): string;
+/**
+ * Generate a snapshot filename from a custom name
+ */
+export declare function generateNamedSnapshotFilename(name: string): string;
+/**
+ * Parse snapshot name from filename
+ */
+export declare function parseSnapshotFilename(filename: string): {
+    isNamed: boolean;
+    nameOrTimestamp: string;
+};
+/**
+ * Create an empty snapshot with default values
+ */
+export declare function createEmptySnapshot(options?: {
+    name?: string;
+    baselineHash?: string;
+    gitRef?: string;
+}): DriftSnapshot;
+/**
+ * Validate a snapshot against the schema
+ */
+export declare function validateSnapshot(data: unknown): {
+    success: boolean;
+    data?: DriftSnapshot;
+    error?: string;
+};
+//# sourceMappingURL=snapshot-schema.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"snapshot-schema.d.ts","sourceRoot":"","sources":["../../src/drift/snapshot-schema.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAEH,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAMxB,eAAO,MAAM,uBAAuB,UAAU,CAAC;AAM/C;;GAEG;AACH,eAAO,MAAM,uBAAuB;;;;;;;;;;;;;iBAUlC,CAAC;AAEH,MAAM,MAAM,iBAAiB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,uBAAuB,CAAC,CAAC;AAMxE;;GAEG;AACH,eAAO,MAAM,yBAAyB;;;;;;;;;;iBAMpC,CAAC;AAEH,MAAM,MAAM,mBAAmB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,yBAAyB,CAAC,CAAC;AAM5E;;GAEG;AACH,eAAO,MAAM,yBAAyB;;;;;;;;;;;;;;iBASpC,CAAC;AAEH,MAAM,MAAM,mBAAmB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,yBAAyB,CAAC,CAAC;AAM5E;;GAEG;AACH,eAAO,MAAM,qBAAqB;;;;;;iBAMhC,CAAC;AAEH,MAAM,MAAM,eAAe,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,qBAAqB,CAAC,CAAC;AAMpE;;GAEG;AACH,eAAO,MAAM,0BAA0B,uCAE4C,CAAC;AAEpF,MAAM,MAAM,oBAAoB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,0BAA0B,CAAC,CAAC;AAM9E;;GAEG;AACH,eAAO,MAAM,aAAa;;;;iBAIxB,CAAC;AAEH,MAAM,MAAM,OAAO,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,aAAa,CAAC,CAAC;AAMpD;;GAEG;AACH,eAAO,MAAM,mBAAmB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBA2B9B,CAAC;AAEH,MAAM,MAAM,aAAa,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,mBAAmB,CAAC,CAAC;AAMhE;;GAEG;AACH,eAAO,MAAM,sBAAsB;;;;;;;;;;;iBAKjC,CAAC;AAEH,MAAM,MAAM,gBAAgB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,sBAAsB,CAAC,CAAC;AAMtE;;GAEG;AACH,wBAAgB,wBAAwB,CAAC,IAAI,GAAE,IAAiB,GAAG,MAAM,CAGxE;AAED;;GAEG;AACH,wBAAgB,6BAA6B,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM,CAGlE;AAED;;GAEG;AACH,wBAAgB,qBAAqB,CAAC,QAAQ,EAAE,MAAM,GAAG;IACvD,OAAO,EAAE,OAAO,CAAC;IACjB,eAAe,EAAE,MAAM,CAAC;CACzB,CAcA;AAED;;GAEG;AACH,wBAAgB,mBAAmB,CAAC,OAAO,CAAC,EAAE;IAC5C,IAAI,CAAC,EAAE,MAAM,CAAC;IACd,YAAY,CAAC,EAAE,MAAM,CAAC;IACtB,MAAM,CAAC,EAAE,MAAM,CAAC;CACjB,GAAG,aAAa,CAkBhB;AAED;;GAEG;AACH,wBAAgB,gBAAgB,CAAC,IAAI,EAAE,OAAO,GAAG;IAC/C,OAAO,EAAE,OAAO,CAAC;IACjB,IAAI,CAAC,EAAE,aAAa,CAAC;IACrB,KAAK,CAAC,EAAE,MAAM,CAAC;CAChB,CAMA"}