cogmem 3.6.2

package/dist/store/PlanRuntimeStore.js

@@ -0,0 +1,257 @@
+import Database from 'bun:sqlite';
+export class PlanRuntimeStore {
+    db;
+    eventStore;
+    constructor(dbPath = ':memory:', eventStore) {
+        this.db = new Database(dbPath);
+        this.eventStore = eventStore;
+        this.initializeSchema();
+    }
+    initializeSchema() {
+        this.db.exec(`
+      CREATE TABLE IF NOT EXISTS runtime_states (
+        runtime_id TEXT NOT NULL,
+        entity_type TEXT NOT NULL,
+        entity_key TEXT NOT NULL,
+        status TEXT NOT NULL,
+        metadata_json TEXT,
+        updated_at INTEGER NOT NULL,
+        PRIMARY KEY (runtime_id, entity_type, entity_key)
+      );
+
+      CREATE INDEX IF NOT EXISTS idx_runtime_states_runtime
+        ON runtime_states(runtime_id, entity_type, updated_at DESC);
+
+      CREATE TABLE IF NOT EXISTS runtime_transitions (
+        transition_id TEXT PRIMARY KEY,
+        runtime_id TEXT NOT NULL,
+        entity_type TEXT NOT NULL,
+        entity_key TEXT NOT NULL,
+        transition_type TEXT NOT NULL,
+        from_status TEXT,
+        to_status TEXT NOT NULL,
+        payload_json TEXT,
+        occurred_at INTEGER NOT NULL
+      );
+
+      CREATE INDEX IF NOT EXISTS idx_runtime_transitions_runtime
+        ON runtime_transitions(runtime_id, occurred_at DESC);
+    `);
+    }
+    upsertState(input, options) {
+        const existing = this.getState(input.runtimeId, input.entityType, input.entityKey);
+        const updatedAt = input.updatedAt ?? Date.now();
+        this.db.prepare(`
+      INSERT OR REPLACE INTO runtime_states (
+        runtime_id, entity_type, entity_key, status, metadata_json, updated_at
+      ) VALUES (?, ?, ?, ?, ?, ?)
+    `).run(input.runtimeId, input.entityType, input.entityKey, input.status, input.metadata ? JSON.stringify(input.metadata) : null, updatedAt);
+        if (!existing || existing.status !== input.status) {
+            this.recordTransition({
+                runtimeId: input.runtimeId,
+                entityType: input.entityType,
+                entityKey: input.entityKey,
+                transitionType: 'state_update',
+                fromStatus: existing?.status,
+                toStatus: input.status,
+                payload: input.metadata,
+                occurredAt: updatedAt
+            });
+        }
+        if (options?.emitEvent !== false) {
+            this.eventStore?.append({
+                streamId: `${input.runtimeId}:${input.entityType}:${input.entityKey}`,
+                streamType: 'system',
+                eventType: 'RUNTIME_STATE_UPDATED',
+                occurredAt: updatedAt,
+                payload: {
+                    runtimeId: input.runtimeId,
+                    entityType: input.entityType,
+                    entityKey: input.entityKey,
+                    status: input.status,
+                    metadata: input.metadata
+                }
+            });
+        }
+    }
+    recordTransition(input, options) {
+        const transitionId = `rt-${input.runtimeId}-${input.entityType}-${input.entityKey}-${input.occurredAt || Date.now()}-${Math.random().toString(36).slice(2, 8)}`;
+        this.db.prepare(`
+      INSERT INTO runtime_transitions (
+        transition_id, runtime_id, entity_type, entity_key, transition_type,
+        from_status, to_status, payload_json, occurred_at
+      ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?)
+    `).run(transitionId, input.runtimeId, input.entityType, input.entityKey, input.transitionType, input.fromStatus || null, input.toStatus, input.payload ? JSON.stringify(input.payload) : null, input.occurredAt ?? Date.now());
+        if (options?.emitEvent !== false) {
+            this.eventStore?.append({
+                streamId: `${input.runtimeId}:${input.entityType}:${input.entityKey}`,
+                streamType: 'system',
+                eventType: 'RUNTIME_TRANSITION_RECORDED',
+                occurredAt: input.occurredAt,
+                payload: {
+                    runtimeId: input.runtimeId,
+                    entityType: input.entityType,
+                    entityKey: input.entityKey,
+                    transitionType: input.transitionType,
+                    fromStatus: input.fromStatus,
+                    toStatus: input.toStatus,
+                    data: input.payload
+                }
+            });
+        }
+    }
+    getState(runtimeId, entityType, entityKey) {
+        const row = this.db.prepare(`
+      SELECT runtime_id, entity_type, entity_key, status, metadata_json, updated_at
+      FROM runtime_states
+      WHERE runtime_id = ? AND entity_type = ? AND entity_key = ?
+    `).get(runtimeId, entityType, entityKey);
+        if (!row)
+            return null;
+        return {
+            runtimeId: row.runtime_id,
+            entityType: row.entity_type,
+            entityKey: row.entity_key,
+            status: row.status,
+            metadata: row.metadata_json ? JSON.parse(row.metadata_json) : undefined,
+            updatedAt: row.updated_at
+        };
+    }
+    getSnapshot(runtimeId) {
+        const states = this.db.prepare(`
+      SELECT runtime_id, entity_type, entity_key, status, metadata_json, updated_at
+      FROM runtime_states
+      WHERE runtime_id = ?
+      ORDER BY entity_type ASC, entity_key ASC
+    `).all(runtimeId);
+        const transitions = this.db.prepare(`
+      SELECT transition_id, runtime_id, entity_type, entity_key, transition_type,
+             from_status, to_status, payload_json, occurred_at
+      FROM runtime_transitions
+      WHERE runtime_id = ?
+      ORDER BY occurred_at ASC, transition_id ASC
+    `).all(runtimeId);
+        return {
+            runtimeId,
+            states: states.map((row) => ({
+                runtimeId: row.runtime_id,
+                entityType: row.entity_type,
+                entityKey: row.entity_key,
+                status: row.status,
+                metadata: row.metadata_json ? JSON.parse(row.metadata_json) : undefined,
+                updatedAt: row.updated_at
+            })),
+            transitions: transitions.map((row) => ({
+                transitionId: row.transition_id,
+                runtimeId: row.runtime_id,
+                entityType: row.entity_type,
+                entityKey: row.entity_key,
+                transitionType: row.transition_type,
+                fromStatus: row.from_status || undefined,
+                toStatus: row.to_status,
+                payload: row.payload_json ? JSON.parse(row.payload_json) : undefined,
+                occurredAt: row.occurred_at
+            }))
+        };
+    }
+    getHistoryPage(runtimeId, page = 1, pageSize = 20, filters) {
+        const safePage = Math.max(page, 1);
+        const safePageSize = Math.max(pageSize, 1);
+        const offset = (safePage - 1) * safePageSize;
+        const transitionConds = ['runtime_id = ?'];
+        const transitionParams = [runtimeId];
+        const stateConds = ['runtime_id = ?'];
+        const stateParams = [runtimeId];
+        if (filters?.entityTypes && filters.entityTypes.length > 0) {
+            const placeholders = filters.entityTypes.map(() => '?').join(', ');
+            transitionConds.push(`entity_type IN (${placeholders})`);
+            stateConds.push(`entity_type IN (${placeholders})`);
+            transitionParams.push(...filters.entityTypes);
+            stateParams.push(...filters.entityTypes);
+        }
+        if (filters?.transitionTypes && filters.transitionTypes.length > 0) {
+            const placeholders = filters.transitionTypes.map(() => '?').join(', ');
+            transitionConds.push(`transition_type IN (${placeholders})`);
+            transitionParams.push(...filters.transitionTypes);
+        }
+        if (filters?.status && filters.status.length > 0) {
+            const placeholders = filters.status.map(() => '?').join(', ');
+            stateConds.push(`status IN (${placeholders})`);
+            stateParams.push(...filters.status);
+        }
+        if (filters?.startTime !== undefined) {
+            transitionConds.push('occurred_at >= ?');
+            stateConds.push('updated_at >= ?');
+            transitionParams.push(filters.startTime);
+            stateParams.push(filters.startTime);
+        }
+        if (filters?.endTime !== undefined) {
+            transitionConds.push('occurred_at <= ?');
+            stateConds.push('updated_at <= ?');
+            transitionParams.push(filters.endTime);
+            stateParams.push(filters.endTime);
+        }
+        const totalRow = this.db.prepare(`
+      SELECT COUNT(*) AS count FROM runtime_transitions WHERE ${transitionConds.join(' AND ')}
+    `).get(...transitionParams);
+        const transitions = this.db.prepare(`
+      SELECT transition_id, runtime_id, entity_type, entity_key, transition_type,
+             from_status, to_status, payload_json, occurred_at
+      FROM runtime_transitions
+      WHERE ${transitionConds.join(' AND ')}
+      ORDER BY occurred_at DESC, transition_id DESC
+      LIMIT ? OFFSET ?
+    `).all(...transitionParams, safePageSize, offset);
+        const states = this.db.prepare(`
+      SELECT runtime_id, entity_type, entity_key, status, metadata_json, updated_at
+      FROM runtime_states
+      WHERE ${stateConds.join(' AND ')}
+      ORDER BY updated_at DESC, entity_type ASC, entity_key ASC
+    `).all(...stateParams);
+        return {
+            runtimeId,
+            page: safePage,
+            pageSize: safePageSize,
+            totalTransitions: totalRow?.count || 0,
+            transitions: transitions.map((row) => ({
+                transitionId: row.transition_id,
+                runtimeId: row.runtime_id,
+                entityType: row.entity_type,
+                entityKey: row.entity_key,
+                transitionType: row.transition_type,
+                fromStatus: row.from_status || undefined,
+                toStatus: row.to_status,
+                payload: row.payload_json ? JSON.parse(row.payload_json) : undefined,
+                occurredAt: row.occurred_at
+            })),
+            currentStates: states.map((row) => ({
+                runtimeId: row.runtime_id,
+                entityType: row.entity_type,
+                entityKey: row.entity_key,
+                status: row.status,
+                metadata: row.metadata_json ? JSON.parse(row.metadata_json) : undefined,
+                updatedAt: row.updated_at
+            })),
+            appliedFilters: {
+                entityTypes: filters?.entityTypes,
+                transitionTypes: filters?.transitionTypes,
+                status: filters?.status,
+                startTime: filters?.startTime,
+                endTime: filters?.endTime
+            }
+        };
+    }
+    getStateCount() {
+        const row = this.db.prepare(`SELECT COUNT(*) AS count FROM runtime_states`).get();
+        return row?.count || 0;
+    }
+    clearAll() {
+        this.db.exec(`
+      DELETE FROM runtime_states;
+      DELETE FROM runtime_transitions;
+    `);
+    }
+    close() {
+        this.db.close();
+    }
+}

package/dist/store/PolicyExecutionProjector.d.ts

@@ -0,0 +1,17 @@
+import type { MemoryEvent } from '../types/index.js';
+import { EventStore } from './EventStore.js';
+import { PolicyExecutionStore } from './PolicyExecutionStore.js';
+import { PolicyProjectionStore } from './PolicyProjectionStore.js';
+export declare class PolicyExecutionProjector {
+    private eventStore;
+    private executionStore;
+    private projectionStore;
+    private projectionName;
+    constructor(eventStore: EventStore, executionStore: PolicyExecutionStore, projectionStore: PolicyProjectionStore, projectionName?: string);
+    bootstrap(): Promise<void>;
+    fullRebuild(reason: string): Promise<void>;
+    replay(events: MemoryEvent[], previousRebuildAt?: number): Promise<void>;
+    private applyEvent;
+    private isPolicyExecutionEvent;
+}
+//# sourceMappingURL=PolicyExecutionProjector.d.ts.map

package/dist/store/PolicyExecutionProjector.js

@@ -0,0 +1,115 @@
+import { logger } from '../utils/Logger.js';
+export class PolicyExecutionProjector {
+    eventStore;
+    executionStore;
+    projectionStore;
+    projectionName;
+    constructor(eventStore, executionStore, projectionStore, projectionName = 'policy_execution_projection_main') {
+        this.eventStore = eventStore;
+        this.executionStore = executionStore;
+        this.projectionStore = projectionStore;
+        this.projectionName = projectionName;
+    }
+    async bootstrap() {
+        const checkpoint = this.projectionStore.getCheckpoint(this.projectionName);
+        const pendingEvents = this.eventStore.getEventsAfter(checkpoint?.lastEventTime)
+            .filter((event) => this.isPolicyExecutionEvent(event));
+        if (!checkpoint) {
+            await this.fullRebuild('initial_build');
+            return;
+        }
+        if (checkpoint.status !== 'ready') {
+            await this.fullRebuild(`checkpoint_${checkpoint.status}`);
+            return;
+        }
+        if (pendingEvents.length === 0) {
+            logger.info(`Policy execution projection ready: projection=${this.projectionName}`);
+            return;
+        }
+        try {
+            await this.replay(pendingEvents, checkpoint.lastRebuildAt);
+        }
+        catch (error) {
+            logger.warn('Policy execution replay failed, falling back to full rebuild', error);
+            await this.fullRebuild('replay_failed');
+        }
+    }
+    async fullRebuild(reason) {
+        logger.warn(`Rebuilding policy execution projection: reason=${reason}`);
+        this.projectionStore.upsertCheckpoint({
+            projectionName: this.projectionName,
+            status: 'building',
+            lastFullCount: 0,
+            metadata: { reason }
+        });
+        this.executionStore.clearAll();
+        const policyEvents = this.eventStore.getEventsAfter(undefined).filter((event) => this.isPolicyExecutionEvent(event));
+        await this.replay(policyEvents);
+    }
+    async replay(events, previousRebuildAt) {
+        if (events.length === 0) {
+            const latestEvent = this.eventStore.getLatestEvent();
+            this.projectionStore.upsertCheckpoint({
+                projectionName: this.projectionName,
+                lastEventId: latestEvent?.eventId,
+                lastEventTime: latestEvent?.occurredAt,
+                lastRebuildAt: previousRebuildAt ?? Date.now(),
+                lastFullCount: this.executionStore.getExecutionCount(),
+                status: 'ready',
+                metadata: { mode: 'incremental_replay', replayedEventCount: 0 }
+            });
+            return;
+        }
+        logger.info(`Replaying policy execution projection events: count=${events.length}`);
+        for (const event of events) {
+            this.applyEvent(event);
+            await Promise.resolve();
+        }
+        const lastEvent = events[events.length - 1];
+        this.projectionStore.upsertCheckpoint({
+            projectionName: this.projectionName,
+            lastEventId: lastEvent?.eventId,
+            lastEventTime: lastEvent?.occurredAt,
+            lastRebuildAt: previousRebuildAt ?? Date.now(),
+            lastFullCount: this.executionStore.getExecutionCount(),
+            status: 'ready',
+            metadata: {
+                mode: 'incremental_replay',
+                replayedEventCount: events.length
+            }
+        });
+    }
+    applyEvent(event) {
+        const payload = (event.payload || {});
+        if (event.eventType !== 'POLICY_EXECUTION_UPDATED')
+            return;
+        if (!payload.executionId || !payload.idempotencyKey || !payload.policy || !payload.action || !payload.status)
+            return;
+        this.executionStore.upsert({
+            executionId: String(payload.executionId),
+            idempotencyKey: String(payload.idempotencyKey),
+            runtimeId: payload.runtimeId ? String(payload.runtimeId) : undefined,
+            policy: String(payload.policy),
+            action: String(payload.action),
+            target: payload.target ? String(payload.target) : undefined,
+            status: String(payload.status),
+            attemptCount: Number(payload.attemptCount || 0),
+            nextRetryAt: payload.nextRetryAt ? Number(payload.nextRetryAt) : undefined,
+            deadLetteredAt: payload.deadLetteredAt ? Number(payload.deadLetteredAt) : undefined,
+            replayPolicy: payload.replayPolicy ? String(payload.replayPolicy) : undefined,
+            actorId: payload.actorId ? String(payload.actorId) : undefined,
+            causationId: payload.causationId ? String(payload.causationId) : undefined,
+            correlationId: payload.correlationId ? String(payload.correlationId) : event.correlationId,
+            policyGroup: payload.policyGroup ? String(payload.policyGroup) : undefined,
+            streamType: payload.streamType ? String(payload.streamType) : event.streamType,
+            eventType: payload.eventType ? String(payload.eventType) : event.eventType,
+            detail: payload.detail ? String(payload.detail) : undefined,
+            metadata: payload.metadata,
+            createdAt: Number(payload.createdAt || event.occurredAt),
+            updatedAt: Number(payload.updatedAt || event.occurredAt)
+        }, { emitEvent: false });
+    }
+    isPolicyExecutionEvent(event) {
+        return event.eventType === 'POLICY_EXECUTION_UPDATED';
+    }
+}

package/dist/store/PolicyExecutionStore.d.ts

@@ -0,0 +1,62 @@
+import type { EventStore } from './EventStore.js';
+import type { PolicyExecutionAuditPage } from '../types/index.js';
+export type PolicyReplayPolicy = 'manual' | 'on_bootstrap' | 'always' | 'scheduled_only';
+export interface PolicyExecutionRecord {
+    executionId: string;
+    idempotencyKey: string;
+    runtimeId?: string;
+    policy: string;
+    action: string;
+    target?: string;
+    status: 'executed' | 'skipped' | 'failed';
+    attemptCount: number;
+    nextRetryAt?: number;
+    deadLetteredAt?: number;
+    replayPolicy?: PolicyReplayPolicy;
+    actorId?: string;
+    causationId?: string;
+    correlationId?: string;
+    policyGroup?: string;
+    streamType?: string;
+    eventType?: string;
+    detail?: string;
+    metadata?: Record<string, unknown>;
+    createdAt: number;
+    updatedAt: number;
+}
+export interface PolicyExecutionAuditFilters {
+    runtimeId?: string;
+    actorId?: string[];
+    causationId?: string[];
+    correlationId?: string[];
+    policyGroup?: string[];
+    streamType?: string[];
+    eventType?: string[];
+    policy?: string[];
+    target?: string[];
+    status?: Array<'executed' | 'skipped' | 'failed'>;
+    replayPolicy?: PolicyReplayPolicy[];
+    startTime?: number;
+    endTime?: number;
+}
+export declare class PolicyExecutionStore {
+    private db;
+    private eventStore?;
+    constructor(dbPath?: string, eventStore?: EventStore);
+    private initializeSchema;
+    getByIdempotencyKey(idempotencyKey: string): PolicyExecutionRecord | null;
+    upsert(record: PolicyExecutionRecord, options?: {
+        emitEvent?: boolean;
+    }): void;
+    listByRuntime(runtimeId: string): PolicyExecutionRecord[];
+    listPendingRetries(now?: number): PolicyExecutionRecord[];
+    listDeadLetters(runtimeId?: string): PolicyExecutionRecord[];
+    listByFilters(filters?: PolicyExecutionAuditFilters): PolicyExecutionRecord[];
+    getAuditPage(page?: number, pageSize?: number, filters?: PolicyExecutionAuditFilters): PolicyExecutionAuditPage;
+    getExecutionCount(): number;
+    clearAll(): void;
+    close(): void;
+    private buildFilterSql;
+    private mapRow;
+}
+//# sourceMappingURL=PolicyExecutionStore.d.ts.map