@ai-sdlc/orchestrator 0.1.0

package/dist/analysis/pattern-detector.d.ts

@@ -0,0 +1,10 @@
+/**
+ * Heuristic architectural pattern detection.
+ * Detects hexagonal, layered, event-driven, MVC, microservices patterns.
+ */
+import type { FileInfo, ModuleInfo, ArchitecturalPattern } from './types.js';
+/**
+ * Detect architectural patterns from file and module structure.
+ */
+export declare function detectPatterns(files: FileInfo[], modules: ModuleInfo[]): ArchitecturalPattern[];
+//# sourceMappingURL=pattern-detector.d.ts.map

package/dist/analysis/pattern-detector.js

@@ -0,0 +1,86 @@
+/**
+ * Heuristic architectural pattern detection.
+ * Detects hexagonal, layered, event-driven, MVC, microservices patterns.
+ */
+const PATTERN_SIGNALS = [
+    {
+        name: 'hexagonal',
+        dirPatterns: [/(?:^|\/)(?:adapters?|ports?|domain|infrastructure|application)\/?/i],
+        filePatterns: [/(?:adapter|port|gateway|repository)\.\w+$/i],
+        description: (ev) => `Ports and adapters detected in ${ev.slice(0, 3).join(', ')}`,
+    },
+    {
+        name: 'layered',
+        dirPatterns: [/(?:^|\/)(?:controllers?|services?|repositories?|models?|middleware)\/?/i],
+        filePatterns: [/(?:controller|service|repository|model|middleware)\.\w+$/i],
+        description: (ev) => `Layered architecture in ${ev.slice(0, 3).join(', ')}`,
+    },
+    {
+        name: 'event-driven',
+        dirPatterns: [/(?:^|\/)(?:events?|handlers?|listeners?|subscribers?|emitters?)\/?/i],
+        filePatterns: [/(?:event|handler|listener|subscriber|emitter|bus)\.\w+$/i],
+        description: (ev) => `Event-driven patterns in ${ev.slice(0, 3).join(', ')}`,
+    },
+    {
+        name: 'mvc',
+        dirPatterns: [/(?:^|\/)(?:views?|controllers?|models?)\/?/i],
+        filePatterns: [/(?:view|controller|model)\.\w+$/i],
+        description: (ev) => `MVC structure in ${ev.slice(0, 3).join(', ')}`,
+    },
+    {
+        name: 'plugin-based',
+        dirPatterns: [/(?:^|\/)(?:plugins?|extensions?|addons?|modules?)\/?/i],
+        filePatterns: [/(?:plugin|extension|addon)\.\w+$/i],
+        description: (ev) => `Plugin architecture in ${ev.slice(0, 3).join(', ')}`,
+    },
+];
+/**
+ * Detect architectural patterns from file and module structure.
+ */
+export function detectPatterns(files, modules) {
+    const patterns = [];
+    const totalFiles = files.length;
+    if (totalFiles === 0)
+        return patterns;
+    for (const signal of PATTERN_SIGNALS) {
+        const evidence = [];
+        // Check directory/module names
+        for (const mod of modules) {
+            for (const re of signal.dirPatterns) {
+                if (re.test(mod.path)) {
+                    evidence.push(mod.path);
+                }
+            }
+        }
+        // Check file paths
+        for (const file of files) {
+            for (const re of signal.dirPatterns) {
+                if (re.test(file.relativePath) && !evidence.includes(file.relativePath)) {
+                    evidence.push(file.relativePath);
+                }
+            }
+            for (const re of signal.filePatterns) {
+                if (re.test(file.relativePath) && !evidence.includes(file.relativePath)) {
+                    evidence.push(file.relativePath);
+                }
+            }
+        }
+        if (evidence.length === 0)
+            continue;
+        // Confidence based on evidence density
+        const confidence = Math.min(evidence.length / Math.max(totalFiles * 0.1, 3), 1);
+        const rounded = Math.round(confidence * 100) / 100;
+        if (rounded >= 0.1) {
+            patterns.push({
+                name: signal.name,
+                confidence: rounded,
+                description: signal.description(evidence),
+                evidence: evidence.slice(0, 10),
+            });
+        }
+    }
+    // Sort by confidence descending
+    patterns.sort((a, b) => b.confidence - a.confidence);
+    return patterns;
+}
+//# sourceMappingURL=pattern-detector.js.map

package/dist/analysis/types.d.ts

@@ -0,0 +1,94 @@
+/**
+ * Types for codebase analysis — the data model for Phase 1 context & routing.
+ */
+/** Information about a module boundary (directory with index.ts or package.json). */
+export interface ModuleInfo {
+    name: string;
+    path: string;
+    fileCount: number;
+    dependencies: string[];
+    dependents: string[];
+}
+/** A file that changes frequently and/or has high complexity. */
+export interface Hotspot {
+    filePath: string;
+    churnRate: number;
+    complexity: number;
+    commitCount: number;
+    lastModified?: string;
+    note?: string;
+}
+/** An architectural pattern detected in the codebase. */
+export interface ArchitecturalPattern {
+    name: string;
+    confidence: number;
+    description: string;
+    evidence: string[];
+}
+/** A detected coding convention. */
+export interface DetectedConvention {
+    category: 'naming' | 'testing' | 'imports' | 'structure' | 'formatting';
+    pattern: string;
+    confidence: number;
+    examples: string[];
+}
+/** Dependency edge in the module graph. */
+export interface DependencyEdge {
+    from: string;
+    to: string;
+    importCount: number;
+}
+/** Module dependency graph. */
+export interface ModuleGraph {
+    modules: ModuleInfo[];
+    edges: DependencyEdge[];
+    externalDependencies: string[];
+    cycles: string[][];
+}
+/** Full codebase analysis profile — persisted in state store. */
+export interface CodebaseProfile {
+    repoPath: string;
+    score: number;
+    filesCount: number;
+    modulesCount: number;
+    dependencyCount: number;
+    modules: ModuleInfo[];
+    moduleGraph: ModuleGraph;
+    architecturalPatterns: ArchitecturalPattern[];
+    hotspots: Hotspot[];
+    conventions: DetectedConvention[];
+    analyzedAt: string;
+}
+/** Context injected into agent prompts. */
+export interface CodebaseContext {
+    score: number;
+    filesCount: number;
+    modulesCount: number;
+    dependencyCount: number;
+    architectureSummary: string;
+    conventionsSummary: string;
+    hotspotsSummary: string;
+}
+/** Options for the analyzer facade. */
+export interface AnalyzerOptions {
+    repoPath: string;
+    include?: string[];
+    exclude?: string[];
+    gitHistoryDays?: number;
+    hotspotThreshold?: number;
+}
+/** File info returned by the file walker. */
+export interface FileInfo {
+    path: string;
+    relativePath: string;
+    lineCount: number;
+    extension: string;
+}
+/** Import statement found by the dependency parser. */
+export interface ImportStatement {
+    source: string;
+    specifier: string;
+    isExternal: boolean;
+    line: number;
+}
+//# sourceMappingURL=types.d.ts.map

package/dist/analysis/types.js

@@ -0,0 +1,5 @@
+/**
+ * Types for codebase analysis — the data model for Phase 1 context & routing.
+ */
+export {};
+//# sourceMappingURL=types.js.map

package/dist/audit-archival.d.ts

@@ -0,0 +1,48 @@
+/**
+ * Audit trail archival — compaction of old entries into gzipped archives.
+ * Preserves chain root hash for continuity verification.
+ */
+import type { AuditEntry } from '@ai-sdlc/reference';
+export interface ArchiveManifest {
+    /** Identifier for this archive. */
+    archiveId: string;
+    /** Number of entries in the archive. */
+    entryCount: number;
+    /** First entry timestamp. */
+    firstTimestamp: string;
+    /** Last entry timestamp. */
+    lastTimestamp: string;
+    /** Hash of the first entry (chain root for this segment). */
+    firstHash: string;
+    /** Hash of the last entry (chain tip for this segment). */
+    lastHash: string;
+    /** When the archive was created. */
+    archivedAt: string;
+    /** Path to the gzipped archive file. */
+    archivePath: string;
+}
+export interface ArchivalOptions {
+    /** Entries older than this are eligible for archival. */
+    olderThanMs: number;
+    /** Base directory for archive files. */
+    archiveDir: string;
+}
+/**
+ * Archive old audit entries to a gzipped JSONL file.
+ * Returns entries that were NOT archived (i.e., still active).
+ */
+export declare function archiveEntries(entries: readonly AuditEntry[], options: ArchivalOptions): Promise<{
+    remaining: AuditEntry[];
+    manifest: ArchiveManifest | null;
+}>;
+/**
+ * Load entries from a gzipped JSONL archive.
+ */
+export declare function loadArchivedEntries(archivePath: string): Promise<AuditEntry[]>;
+/**
+ * Verify that an archive's chain links correctly to a continuation hash.
+ * The last entry's hash in the archive should match the previousHash
+ * of the first remaining entry.
+ */
+export declare function verifyArchiveContinuity(manifest: ArchiveManifest, firstRemainingEntry: AuditEntry | undefined): boolean;
+//# sourceMappingURL=audit-archival.d.ts.map

package/dist/audit-archival.js

@@ -0,0 +1,72 @@
+/**
+ * Audit trail archival — compaction of old entries into gzipped archives.
+ * Preserves chain root hash for continuity verification.
+ */
+import { createGzip, createGunzip } from 'node:zlib';
+import { createReadStream, createWriteStream, existsSync } from 'node:fs';
+import { writeFile, unlink } from 'node:fs/promises';
+import { pipeline } from 'node:stream/promises';
+/**
+ * Archive old audit entries to a gzipped JSONL file.
+ * Returns entries that were NOT archived (i.e., still active).
+ */
+export async function archiveEntries(entries, options) {
+    const cutoff = new Date(Date.now() - options.olderThanMs).toISOString();
+    const toArchive = entries.filter((e) => e.timestamp < cutoff);
+    const remaining = entries.filter((e) => e.timestamp >= cutoff);
+    if (toArchive.length === 0) {
+        return { remaining: [...remaining], manifest: null };
+    }
+    const archiveId = `archive-${Date.now()}`;
+    const archivePath = `${options.archiveDir}/${archiveId}.jsonl.gz`;
+    // Write JSONL then gzip
+    const jsonl = toArchive.map((e) => JSON.stringify(e)).join('\n');
+    const tmpPath = `${options.archiveDir}/${archiveId}.jsonl`;
+    await writeFile(tmpPath, jsonl, 'utf-8');
+    // Gzip the file
+    await pipeline(createReadStream(tmpPath), createGzip(), createWriteStream(archivePath));
+    await unlink(tmpPath);
+    const manifest = {
+        archiveId,
+        entryCount: toArchive.length,
+        firstTimestamp: toArchive[0].timestamp,
+        lastTimestamp: toArchive[toArchive.length - 1].timestamp,
+        firstHash: toArchive[0].hash ?? '',
+        lastHash: toArchive[toArchive.length - 1].hash ?? '',
+        archivedAt: new Date().toISOString(),
+        archivePath,
+    };
+    return { remaining: [...remaining], manifest };
+}
+/**
+ * Load entries from a gzipped JSONL archive.
+ */
+export async function loadArchivedEntries(archivePath) {
+    if (!existsSync(archivePath))
+        return [];
+    const chunks = [];
+    await pipeline(createReadStream(archivePath), createGunzip(), async function* collect(source) {
+        for await (const chunk of source) {
+            chunks.push(Buffer.from(chunk));
+        }
+        yield Buffer.alloc(0);
+    });
+    const content = Buffer.concat(chunks).toString('utf-8');
+    if (!content.trim())
+        return [];
+    return content
+        .split('\n')
+        .filter(Boolean)
+        .map((line) => JSON.parse(line));
+}
+/**
+ * Verify that an archive's chain links correctly to a continuation hash.
+ * The last entry's hash in the archive should match the previousHash
+ * of the first remaining entry.
+ */
+export function verifyArchiveContinuity(manifest, firstRemainingEntry) {
+    if (!firstRemainingEntry)
+        return true; // nothing to chain to
+    return firstRemainingEntry.previousHash === manifest.lastHash;
+}
+//# sourceMappingURL=audit-archival.js.map

package/dist/audit-export.d.ts

@@ -0,0 +1,45 @@
+/**
+ * Audit trail export — JSON, CSV, JSONL formats with filter support.
+ */
+import type { AuditEntry, AuditFilter, AuditLog } from '@ai-sdlc/reference';
+export type ExportFormat = 'json' | 'csv' | 'jsonl';
+export interface ExportOptions {
+    /** Output format. */
+    format: ExportFormat;
+    /** Optional filter to apply before export. */
+    filter?: AuditFilter;
+    /** Include hash/integrity fields in output (defaults to true). */
+    includeIntegrity?: boolean;
+}
+export interface ComplianceReportOptions {
+    /** Report title. */
+    title: string;
+    /** Audit log to report on. */
+    auditLog: AuditLog;
+    /** Filter entries for the report period. */
+    filter?: AuditFilter;
+    /** Include integrity verification result. */
+    verifyIntegrity?: boolean;
+}
+export interface ComplianceReport {
+    title: string;
+    generatedAt: string;
+    entryCount: number;
+    actorSummary: Record<string, number>;
+    actionSummary: Record<string, number>;
+    decisionSummary: Record<string, number>;
+    integrityResult?: {
+        valid: boolean;
+        brokenAt?: number;
+    };
+    entries: AuditEntry[];
+}
+/**
+ * Export audit entries to the specified format.
+ */
+export declare function exportAuditEntries(entries: readonly AuditEntry[], options: ExportOptions): string;
+/**
+ * Generate a compliance-ready audit report.
+ */
+export declare function generateComplianceReport(options: ComplianceReportOptions): ComplianceReport;
+//# sourceMappingURL=audit-export.d.ts.map

package/dist/audit-export.js

@@ -0,0 +1,100 @@
+/**
+ * Audit trail export — JSON, CSV, JSONL formats with filter support.
+ */
+/**
+ * Export audit entries to the specified format.
+ */
+export function exportAuditEntries(entries, options) {
+    const includeIntegrity = options.includeIntegrity ?? true;
+    const filtered = options.filter
+        ? entries.filter((e) => matchesFilter(e, options.filter))
+        : entries;
+    switch (options.format) {
+        case 'json':
+            return JSON.stringify(filtered.map((e) => formatEntry(e, includeIntegrity)), null, 2);
+        case 'jsonl':
+            return filtered.map((e) => JSON.stringify(formatEntry(e, includeIntegrity))).join('\n');
+        case 'csv': {
+            const headers = includeIntegrity
+                ? ['id', 'timestamp', 'actor', 'action', 'resource', 'decision', 'hash', 'previousHash']
+                : ['id', 'timestamp', 'actor', 'action', 'resource', 'decision'];
+            const rows = filtered.map((e) => headers.map((h) => csvEscape(String(e[h] ?? ''))).join(','));
+            return [headers.join(','), ...rows].join('\n');
+        }
+        default:
+            throw new Error(`Unsupported format: ${options.format}`);
+    }
+}
+/**
+ * Generate a compliance-ready audit report.
+ */
+export function generateComplianceReport(options) {
+    const allEntries = options.auditLog.entries();
+    const filtered = options.filter
+        ? allEntries.filter((e) => matchesFilter(e, options.filter))
+        : allEntries;
+    const actorSummary = {};
+    const actionSummary = {};
+    const decisionSummary = {};
+    for (const entry of filtered) {
+        actorSummary[entry.actor] = (actorSummary[entry.actor] ?? 0) + 1;
+        actionSummary[entry.action] = (actionSummary[entry.action] ?? 0) + 1;
+        decisionSummary[entry.decision] = (decisionSummary[entry.decision] ?? 0) + 1;
+    }
+    const report = {
+        title: options.title,
+        generatedAt: new Date().toISOString(),
+        entryCount: filtered.length,
+        actorSummary,
+        actionSummary,
+        decisionSummary,
+        entries: [...filtered],
+    };
+    if (options.verifyIntegrity) {
+        const result = options.auditLog.verifyIntegrity();
+        report.integrityResult = { valid: result.valid, brokenAt: result.brokenAt };
+    }
+    return report;
+}
+// ── Helpers ───────────────────────────────────────────────────────
+function matchesFilter(entry, filter) {
+    if (filter.actor && entry.actor !== filter.actor)
+        return false;
+    if (filter.action && entry.action !== filter.action)
+        return false;
+    if (filter.resource && entry.resource !== filter.resource)
+        return false;
+    if (filter.decision && entry.decision !== filter.decision)
+        return false;
+    if (filter.from && entry.timestamp < filter.from)
+        return false;
+    if (filter.to && entry.timestamp > filter.to)
+        return false;
+    return true;
+}
+function formatEntry(entry, includeIntegrity) {
+    const base = {
+        id: entry.id,
+        timestamp: entry.timestamp,
+        actor: entry.actor,
+        action: entry.action,
+        resource: entry.resource,
+        decision: entry.decision,
+    };
+    if (entry.details)
+        base.details = entry.details;
+    if (entry.policy)
+        base.policy = entry.policy;
+    if (includeIntegrity) {
+        base.hash = entry.hash;
+        base.previousHash = entry.previousHash;
+    }
+    return base;
+}
+function csvEscape(value) {
+    if (value.includes(',') || value.includes('"') || value.includes('\n')) {
+        return `"${value.replace(/"/g, '""')}"`;
+    }
+    return value;
+}
+//# sourceMappingURL=audit-export.js.map

package/dist/audit-extended.d.ts

@@ -0,0 +1,28 @@
+/**
+ * Extended audit integration — covers file-based persistence, integrity
+ * verification, rotation, and hash computation from the reference audit module.
+ */
+import { computeEntryHash, createFileSink, loadEntriesFromFile, verifyFileIntegrity, rotateAuditFile, createAuditLog, type AuditEntry, type AuditFilter, type AuditSink, type AuditLog, type IntegrityResult } from '@ai-sdlc/reference';
+/**
+ * Create a file-backed audit log with integrity verification.
+ */
+export declare function createFileAuditLog(filePath: string): AuditLog;
+/**
+ * Verify the integrity of an audit log file (hash chain verification).
+ */
+export declare function verifyAuditIntegrity(filePath: string): Promise<IntegrityResult>;
+/**
+ * Load all audit entries from a file for querying/analysis.
+ */
+export declare function loadAuditEntries(filePath: string): Promise<AuditEntry[]>;
+/**
+ * Rotate an audit log file (archive and create new).
+ */
+export declare function rotateAuditLog(filePath: string): Promise<string>;
+/**
+ * Compute a SHA-256 hash for an audit entry (for manual chain building).
+ */
+export declare function computeAuditHash(entry: AuditEntry, previousHash?: string): string;
+export { computeEntryHash, createFileSink, loadEntriesFromFile, verifyFileIntegrity, rotateAuditFile, createAuditLog, };
+export type { AuditEntry, AuditFilter, AuditSink, AuditLog, IntegrityResult };
+//# sourceMappingURL=audit-extended.d.ts.map

package/dist/audit-extended.js

@@ -0,0 +1,38 @@
+/**
+ * Extended audit integration — covers file-based persistence, integrity
+ * verification, rotation, and hash computation from the reference audit module.
+ */
+import { computeEntryHash, createFileSink, loadEntriesFromFile, verifyFileIntegrity, rotateAuditFile, createAuditLog, } from '@ai-sdlc/reference';
+/**
+ * Create a file-backed audit log with integrity verification.
+ */
+export function createFileAuditLog(filePath) {
+    const sink = createFileSink(filePath);
+    return createAuditLog(sink);
+}
+/**
+ * Verify the integrity of an audit log file (hash chain verification).
+ */
+export async function verifyAuditIntegrity(filePath) {
+    return verifyFileIntegrity(filePath);
+}
+/**
+ * Load all audit entries from a file for querying/analysis.
+ */
+export async function loadAuditEntries(filePath) {
+    return loadEntriesFromFile(filePath);
+}
+/**
+ * Rotate an audit log file (archive and create new).
+ */
+export async function rotateAuditLog(filePath) {
+    return rotateAuditFile(filePath);
+}
+/**
+ * Compute a SHA-256 hash for an audit entry (for manual chain building).
+ */
+export function computeAuditHash(entry, previousHash) {
+    return computeEntryHash(entry, previousHash);
+}
+export { computeEntryHash, createFileSink, loadEntriesFromFile, verifyFileIntegrity, rotateAuditFile, createAuditLog, };
+//# sourceMappingURL=audit-extended.js.map

package/dist/audit-scheduler.d.ts

@@ -0,0 +1,32 @@
+/**
+ * Periodic audit integrity verification and key rotation scheduler.
+ */
+import type { AuditLog, IntegrityResult } from '@ai-sdlc/reference';
+export interface AuditSchedulerConfig {
+    /** Audit log to verify. */
+    auditLog: AuditLog;
+    /** Interval in ms between integrity checks (defaults to 60000). */
+    verifyIntervalMs?: number;
+    /** Callback when integrity check fails. */
+    onIntegrityFailure?: (result: IntegrityResult) => void;
+    /** Callback when integrity check succeeds. */
+    onIntegritySuccess?: (result: IntegrityResult) => void;
+    /** Optional key rotation callback (called on rotation interval). */
+    onRotation?: () => void;
+    /** Interval in ms between key rotations (0 = disabled). */
+    rotationIntervalMs?: number;
+}
+export interface AuditScheduler {
+    /** Start the scheduler. */
+    start(): void;
+    /** Stop the scheduler. */
+    stop(): void;
+    /** Run a manual integrity check. */
+    verify(): IntegrityResult;
+    /** Whether the scheduler is currently running. */
+    readonly running: boolean;
+    /** Number of checks performed. */
+    readonly checkCount: number;
+}
+export declare function createAuditScheduler(config: AuditSchedulerConfig): AuditScheduler;
+//# sourceMappingURL=audit-scheduler.d.ts.map

package/dist/audit-scheduler.js

@@ -0,0 +1,52 @@
+/**
+ * Periodic audit integrity verification and key rotation scheduler.
+ */
+export function createAuditScheduler(config) {
+    const verifyIntervalMs = config.verifyIntervalMs ?? 60_000;
+    const rotationIntervalMs = config.rotationIntervalMs ?? 0;
+    let verifyTimer = null;
+    let rotationTimer = null;
+    let _running = false;
+    let _checkCount = 0;
+    function verify() {
+        _checkCount++;
+        const result = config.auditLog.verifyIntegrity();
+        if (result.valid) {
+            config.onIntegritySuccess?.(result);
+        }
+        else {
+            config.onIntegrityFailure?.(result);
+        }
+        return result;
+    }
+    return {
+        start() {
+            if (_running)
+                return;
+            _running = true;
+            verifyTimer = setInterval(verify, verifyIntervalMs);
+            if (rotationIntervalMs > 0 && config.onRotation) {
+                rotationTimer = setInterval(config.onRotation, rotationIntervalMs);
+            }
+        },
+        stop() {
+            _running = false;
+            if (verifyTimer) {
+                clearInterval(verifyTimer);
+                verifyTimer = null;
+            }
+            if (rotationTimer) {
+                clearInterval(rotationTimer);
+                rotationTimer = null;
+            }
+        },
+        verify,
+        get running() {
+            return _running;
+        },
+        get checkCount() {
+            return _checkCount;
+        },
+    };
+}
+//# sourceMappingURL=audit-scheduler.js.map

package/dist/audit-sqlite-sink.d.ts

@@ -0,0 +1,11 @@
+/**
+ * SQLite-backed audit sink using the state store's audit_entries table.
+ * Provides indexed queries by actor, action, resource, and time range.
+ */
+import type { AuditSink } from '@ai-sdlc/reference';
+import type { StateStore } from './state/index.js';
+/**
+ * Create an audit sink that persists entries to the SQLite state store.
+ */
+export declare function createSqliteAuditSink(store: StateStore): AuditSink;
+//# sourceMappingURL=audit-sqlite-sink.d.ts.map

package/dist/audit-sqlite-sink.js

@@ -0,0 +1,51 @@
+/**
+ * SQLite-backed audit sink using the state store's audit_entries table.
+ * Provides indexed queries by actor, action, resource, and time range.
+ */
+/**
+ * Create an audit sink that persists entries to the SQLite state store.
+ */
+export function createSqliteAuditSink(store) {
+    return {
+        write(entry) {
+            store.saveAuditEntry({
+                entryId: entry.id,
+                actor: entry.actor,
+                action: entry.action,
+                resourceType: entry.resource.split('/')[0],
+                resourceId: entry.resource,
+                detail: entry.details ? JSON.stringify(entry.details) : undefined,
+                hash: entry.hash,
+                previousHash: entry.previousHash,
+                createdAt: entry.timestamp,
+            });
+        },
+        async query(filter) {
+            const records = store.queryAuditEntries({
+                actor: filter.actor,
+                action: filter.action,
+                resourceType: filter.resource?.split('/')[0],
+                since: filter.from,
+                until: filter.to,
+            });
+            return records
+                .filter((r) => {
+                if (filter.resource && r.resourceId !== filter.resource)
+                    return false;
+                return true;
+            })
+                .map((r) => ({
+                id: r.entryId,
+                timestamp: r.createdAt ?? '',
+                actor: r.actor,
+                action: r.action,
+                resource: r.resourceId ?? r.resourceType ?? '',
+                decision: 'allowed',
+                details: r.detail ? JSON.parse(r.detail) : undefined,
+                hash: r.hash,
+                previousHash: r.previousHash,
+            }));
+        },
+    };
+}
+//# sourceMappingURL=audit-sqlite-sink.js.map