pi-harness-runtime 1.1.335 → 1.1.337

package/packages/event-sink/dist/projection.js

@@ -0,0 +1,62 @@
+/**
+ * Projection Store
+ *
+ * Maintains materialized views of events for efficient queries.
+ * Projections are updated atomically with events.
+ */
+/**
+ * Projection Store
+ */
+export class ProjectionStore {
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    projections = new Map();
+    /**
+     * Register a projection
+     */
+    register(projection) {
+        this.projections.set(projection.name, {
+            name: projection.name,
+            state: projection.initialState,
+            initialState: projection.initialState,
+            reduce: projection.reduce,
+        });
+    }
+    /**
+     * Apply events to all projections
+     */
+    apply(events) {
+        for (const event of events) {
+            for (const [name, entry] of this.projections.entries()) {
+                try {
+                    entry.state = entry.reduce(entry.state, event);
+                }
+                catch {
+                    // Silently ignore projection errors - don't crash the event loop
+                    // callers can check projection state after apply()
+                }
+            }
+        }
+    }
+    /**
+     * Get projection state
+     */
+    get(name) {
+        const entry = this.projections.get(name);
+        return entry ? entry.state : null;
+    }
+    /**
+     * Reset projection to initial state
+     */
+    reset(name) {
+        const entry = this.projections.get(name);
+        if (entry) {
+            entry.state = entry.initialState;
+        }
+    }
+    /**
+     * List all projection names
+     */
+    list() {
+        return Array.from(this.projections.keys());
+    }
+}

package/packages/event-sink/dist/sink.d.ts

@@ -0,0 +1,81 @@
+/**
+ * Event Sink - Atomic Event Sourcing
+ *
+ * Inspired by T3Code's orchestrator:
+ * - Events + projections + outbox effects committed atomically
+ * - Command acknowledgement = intent committed, not work finished
+ */
+/**
+ * Event with metadata
+ */
+export interface StoredEvent {
+    id: string;
+    type: string;
+    timestamp: string;
+    workspaceId?: string;
+    sessionId?: string;
+    jobId?: string;
+    payload?: Record<string, unknown>;
+    metadata?: Record<string, unknown>;
+    commandId?: string;
+    sequence: number;
+}
+/**
+ * Outbox entry for side effects
+ */
+export interface OutboxEntry {
+    id: string;
+    eventId: string;
+    effect: string;
+    payload: unknown;
+    status: 'pending' | 'processing' | 'completed' | 'failed';
+    attempts: number;
+    lastError?: string;
+    createdAt: string;
+    processedAt?: string;
+}
+/**
+ * Event Sink options
+ */
+export interface EventSinkOptions {
+    /** Database file path */
+    dbPath: string;
+    /** Called when events are committed */
+    onEventsCommitted?: (events: StoredEvent[]) => void;
+}
+/**
+ * Event Sink - Atomic event sourcing
+ */
+export declare class EventSink {
+    private db;
+    private sequence;
+    private onEventsCommitted?;
+    constructor(options: EventSinkOptions);
+    /**
+     * Commit events atomically with projections and outbox
+     */
+    commit<T extends StoredEvent>(events: T[], outboxEffects?: Array<{
+        effect: string;
+        payload: unknown;
+    }>): Promise<{
+        events: StoredEvent[];
+        outbox: OutboxEntry[];
+    }>;
+    /**
+     * Get events by filter
+     */
+    getEvents(filter?: {
+        types?: string[];
+        since?: number;
+        until?: number;
+        limit?: number;
+    }): Promise<StoredEvent[]>;
+    /**
+     * Get pending outbox entries
+     */
+    getPendingOutbox(limit?: number): Promise<OutboxEntry[]>;
+    /**
+     * Update outbox entry status
+     */
+    updateOutboxStatus(id: string, status: OutboxEntry['status'], error?: string): Promise<void>;
+}

package/packages/event-sink/dist/sink.js

@@ -0,0 +1,106 @@
+/**
+ * Event Sink - Atomic Event Sourcing
+ *
+ * Inspired by T3Code's orchestrator:
+ * - Events + projections + outbox effects committed atomically
+ * - Command acknowledgement = intent committed, not work finished
+ */
+/**
+ * Event Sink - Atomic event sourcing
+ */
+export class EventSink {
+    db = new Map();
+    sequence = 0;
+    onEventsCommitted;
+    constructor(options) {
+        this.onEventsCommitted = options.onEventsCommitted;
+    }
+    /**
+     * Commit events atomically with projections and outbox
+     */
+    async commit(events, outboxEffects = []) {
+        const committedEvents = [];
+        const outbox = [];
+        // Assign sequence numbers atomically
+        for (const event of events) {
+            this.sequence++;
+            const storedEvent = {
+                ...event,
+                sequence: this.sequence,
+            };
+            committedEvents.push(storedEvent);
+            // Store event
+            this.db.set(`event:${storedEvent.id}`, storedEvent);
+        }
+        // Create outbox entries
+        for (const effect of outboxEffects) {
+            const entry = {
+                id: crypto.randomUUID(),
+                eventId: committedEvents[0]?.id || '',
+                effect: effect.effect,
+                payload: effect.payload,
+                status: 'pending',
+                attempts: 0,
+                createdAt: new Date().toISOString(),
+            };
+            outbox.push(entry);
+            this.db.set(`outbox:${entry.id}`, entry);
+        }
+        // Notify listeners
+        this.onEventsCommitted?.(committedEvents);
+        return { events: committedEvents, outbox };
+    }
+    /**
+     * Get events by filter
+     */
+    async getEvents(filter) {
+        const events = [];
+        const limit = filter?.limit || 100;
+        for (const [key, value] of this.db.entries()) {
+            if (key.startsWith('event:') && typeof value === 'object') {
+                const event = value;
+                if (filter?.types && !filter.types.includes(event.type))
+                    continue;
+                if (filter?.since && event.sequence <= filter.since)
+                    continue;
+                if (filter?.until && event.sequence >= filter.until)
+                    continue;
+                events.push(event);
+                if (events.length >= limit)
+                    break;
+            }
+        }
+        return events.sort((a, b) => a.sequence - b.sequence);
+    }
+    /**
+     * Get pending outbox entries
+     */
+    async getPendingOutbox(limit = 10) {
+        const entries = [];
+        for (const [key, value] of this.db.entries()) {
+            if (key.startsWith('outbox:') && typeof value === 'object') {
+                const entry = value;
+                if (entry.status === 'pending' || entry.status === 'failed') {
+                    entries.push(entry);
+                    if (entries.length >= limit)
+                        break;
+                }
+            }
+        }
+        return entries;
+    }
+    /**
+     * Update outbox entry status
+     */
+    async updateOutboxStatus(id, status, error) {
+        const entry = this.db.get(`outbox:${id}`);
+        if (entry) {
+            entry.status = status;
+            entry.lastError = error;
+            entry.attempts++;
+            if (status === 'completed') {
+                entry.processedAt = new Date().toISOString();
+            }
+        }
+    }
+}

package/packages/event-sink/package.json

@@ -0,0 +1,28 @@
+{
+  "name": "@pi-harness/event-sink",
+  "version": "1.1.337",
+  "type": "module",
+  "description": "Atomic event sourcing with SQLite transactions for pi-harness",
+  "main": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "exports": {
+    ".": {
+      "import": "./dist/index.js",
+      "types": "./dist/index.d.ts"
+    }
+  },
+  "scripts": {
+    "build": "tsc",
+    "test": "bun test"
+  },
+  "dependencies": {
+    "@pi-harness/contracts": "workspace:*",
+    "better-sqlite3": "^11.7.0",
+    "uuid": "^11.0.3"
+  },
+  "devDependencies": {
+    "typescript": "^5.7.2",
+    "@types/better-sqlite3": "^7.6.12",
+    "@types/uuid": "^10.0.0"
+  }
+}

package/packages/event-sink/src/index.ts

@@ -0,0 +1,15 @@
+/**
+ * Event Sink - Atomic Event Sourcing
+ * 
+ * Inspired by T3Code's orchestrator event sourcing:
+ * - Commands serialize to event log
+ * - EventSink commits events + projections + outbox effects atomically
+ * - EffectWorker performs side effects AFTER intent commits
+ * - Command acknowledgement = intent committed, not work finished
+ */
+
+import type { EventCreate } from '@pi-harness/contracts';
+
+export { EventSink } from './sink.js';
+export { ProjectionStore } from './projection.js';
+export { OutboxWorker } from './outbox.js';

package/packages/event-sink/src/outbox.ts

@@ -0,0 +1,119 @@
+/**
+ * Outbox Worker
+ * 
+ * Processes outbox entries after events are committed.
+ * Side effects are performed asynchronously.
+ */
+
+import type { OutboxEntry } from './sink.js';
+
+/**
+ * Effect handler function
+ */
+export type EffectHandler = (payload: unknown) => Promise<void>;
+
+/**
+ * Outbox Worker options
+ */
+export interface OutboxWorkerOptions {
+  /** Maximum retry attempts */
+  maxRetries?: number;
+  /** Retry delay in ms */
+  retryDelay?: number;
+  /** Effect handlers */
+  handlers?: Record<string, EffectHandler>;
+}
+
+/**
+ * Outbox Worker
+ * 
+ * Processes pending outbox entries and executes their effects.
+ */
+export class OutboxWorker {
+  private maxRetries: number;
+  private retryDelay: number;
+  private handlers: Map<string, EffectHandler> = new Map();
+  private running = false;
+  private interval?: ReturnType<typeof setInterval>;
+
+  constructor(options: OutboxWorkerOptions = {}) {
+    this.maxRetries = options.maxRetries ?? 3;
+    this.retryDelay = options.retryDelay ?? 1000;
+    
+    if (options.handlers) {
+      for (const [name, handler] of Object.entries(options.handlers)) {
+        this.handlers.set(name, handler);
+      }
+    }
+  }
+
+  /**
+   * Register an effect handler
+   */
+  register(effect: string, handler: EffectHandler): void {
+    this.handlers.set(effect, handler);
+  }
+
+  /**
+   * Start processing outbox
+   */
+  start(
+    getPending: () => Promise<OutboxEntry[]>,
+    updateStatus: (id: string, status: OutboxEntry['status'], error?: string) => Promise<void>,
+    pollInterval = 1000,
+  ): void {
+    if (this.running) return;
+    this.running = true;
+
+    this.interval = setInterval(async () => {
+      if (!this.running) return;
+      
+      try {
+        const entries = await getPending();
+        
+        for (const entry of entries) {
+          if (!this.running) break;
+          
+          if (entry.attempts >= this.maxRetries) {
+            await updateStatus(entry.id, 'failed', 'Max retries exceeded');
+            continue;
+          }
+
+          const handler = this.handlers.get(entry.effect);
+          if (!handler) {
+            await updateStatus(entry.id, 'failed', `No handler for effect: ${entry.effect}`);
+            continue;
+          }
+
+          try {
+            await updateStatus(entry.id, 'processing');
+            await handler(entry.payload);
+            await updateStatus(entry.id, 'completed');
+          } catch (error) {
+            await updateStatus(entry.id, 'failed', String(error));
+          }
+        }
+      } catch (error) {
+        console.error('[OutboxWorker] Error processing outbox:', error);
+      }
+    }, pollInterval);
+  }
+
+  /**
+   * Stop processing
+   */
+  stop(): void {
+    this.running = false;
+    if (this.interval) {
+      clearInterval(this.interval);
+      this.interval = undefined;
+    }
+  }
+
+  /**
+   * Check if running
+   */
+  isRunning(): boolean {
+    return this.running;
+  }
+}

package/packages/event-sink/src/projection.ts

@@ -0,0 +1,84 @@
+/**
+ * Projection Store
+ * 
+ * Maintains materialized views of events for efficient queries.
+ * Projections are updated atomically with events.
+ */
+
+import type { StoredEvent } from './sink.js';
+
+/**
+ * Projection function type
+ */
+export type ProjectionFn<T> = (state: T | null, event: StoredEvent) => T;
+
+/**
+ * Internal projection entry with state
+ */
+interface ProjectionEntry<T> {
+  name: string;
+  state: T;
+  initialState: T;
+  reduce: ProjectionFn<T>;
+}
+
+/**
+ * Projection Store
+ */
+export class ProjectionStore {
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any
+  private projections = new Map<string, ProjectionEntry<any>>();
+
+  /**
+   * Register a projection
+   */
+  register<T>(projection: { name: string; initialState: T; reduce: ProjectionFn<T> }): void {
+    this.projections.set(projection.name, {
+      name: projection.name,
+      state: projection.initialState,
+      initialState: projection.initialState,
+      reduce: projection.reduce,
+    });
+  }
+
+  /**
+   * Apply events to all projections
+   */
+  apply(events: StoredEvent[]): void {
+    for (const event of events) {
+      for (const [name, entry] of this.projections.entries()) {
+        try {
+          entry.state = entry.reduce(entry.state, event);
+        } catch {
+          // Silently ignore projection errors - don't crash the event loop
+          // callers can check projection state after apply()
+        }
+      }
+    }
+  }
+
+  /**
+   * Get projection state
+   */
+  get<T>(name: string): T | null {
+    const entry = this.projections.get(name);
+    return entry ? entry.state : null;
+  }
+
+  /**
+   * Reset projection to initial state
+   */
+  reset(name: string): void {
+    const entry = this.projections.get(name);
+    if (entry) {
+      entry.state = entry.initialState;
+    }
+  }
+
+  /**
+   * List all projection names
+   */
+  list(): string[] {
+    return Array.from(this.projections.keys());
+  }
+}

package/packages/event-sink/src/sink.ts

@@ -0,0 +1,167 @@
+/**
+ * Event Sink - Atomic Event Sourcing
+ * 
+ * Inspired by T3Code's orchestrator:
+ * - Events + projections + outbox effects committed atomically
+ * - Command acknowledgement = intent committed, not work finished
+ */
+
+/**
+ * Event with metadata
+ */
+export interface StoredEvent {
+  id: string;
+  type: string;
+  timestamp: string;
+  workspaceId?: string;
+  sessionId?: string;
+  jobId?: string;
+  payload?: Record<string, unknown>;
+  metadata?: Record<string, unknown>;
+  commandId?: string;
+  sequence: number;
+}
+
+/**
+ * Outbox entry for side effects
+ */
+export interface OutboxEntry {
+  id: string;
+  eventId: string;
+  effect: string;
+  payload: unknown;
+  status: 'pending' | 'processing' | 'completed' | 'failed';
+  attempts: number;
+  lastError?: string;
+  createdAt: string;
+  processedAt?: string;
+}
+
+/**
+ * Event Sink options
+ */
+export interface EventSinkOptions {
+  /** Database file path */
+  dbPath: string;
+  /** Called when events are committed */
+  onEventsCommitted?: (events: StoredEvent[]) => void;
+}
+
+/**
+ * Event Sink - Atomic event sourcing
+ */
+export class EventSink {
+  private db: Map<string, unknown> = new Map();
+  private sequence = 0;
+  private onEventsCommitted?: (events: StoredEvent[]) => void;
+
+  constructor(options: EventSinkOptions) {
+    this.onEventsCommitted = options.onEventsCommitted;
+  }
+
+  /**
+   * Commit events atomically with projections and outbox
+   */
+  async commit<T extends StoredEvent>(
+    events: T[],
+    outboxEffects: Array<{ effect: string; payload: unknown }> = [],
+  ): Promise<{ events: StoredEvent[]; outbox: OutboxEntry[] }> {
+    const committedEvents: StoredEvent[] = [];
+    const outbox: OutboxEntry[] = [];
+
+    // Assign sequence numbers atomically
+    for (const event of events) {
+      this.sequence++;
+      const storedEvent: StoredEvent = {
+        ...event,
+        sequence: this.sequence,
+      };
+      committedEvents.push(storedEvent);
+      
+      // Store event
+      this.db.set(`event:${storedEvent.id}`, storedEvent);
+    }
+
+    // Create outbox entries
+    for (const effect of outboxEffects) {
+      const entry: OutboxEntry = {
+        id: crypto.randomUUID(),
+        eventId: committedEvents[0]?.id || '',
+        effect: effect.effect,
+        payload: effect.payload,
+        status: 'pending',
+        attempts: 0,
+        createdAt: new Date().toISOString(),
+      };
+      outbox.push(entry);
+      this.db.set(`outbox:${entry.id}`, entry);
+    }
+
+    // Notify listeners
+    this.onEventsCommitted?.(committedEvents);
+
+    return { events: committedEvents, outbox };
+  }
+
+  /**
+   * Get events by filter
+   */
+  async getEvents(filter?: {
+    types?: string[];
+    since?: number;
+    until?: number;
+    limit?: number;
+  }): Promise<StoredEvent[]> {
+    const events: StoredEvent[] = [];
+    const limit = filter?.limit || 100;
+
+    for (const [key, value] of this.db.entries()) {
+      if (key.startsWith('event:') && typeof value === 'object') {
+        const event = value as StoredEvent;
+        
+        if (filter?.types && !filter.types.includes(event.type)) continue;
+        if (filter?.since && event.sequence <= filter.since) continue;
+        if (filter?.until && event.sequence >= filter.until) continue;
+        
+        events.push(event);
+        if (events.length >= limit) break;
+      }
+    }
+
+    return events.sort((a, b) => a.sequence - b.sequence);
+  }
+
+  /**
+   * Get pending outbox entries
+   */
+  async getPendingOutbox(limit = 10): Promise<OutboxEntry[]> {
+    const entries: OutboxEntry[] = [];
+
+    for (const [key, value] of this.db.entries()) {
+      if (key.startsWith('outbox:') && typeof value === 'object') {
+        const entry = value as OutboxEntry;
+        if (entry.status === 'pending' || entry.status === 'failed') {
+          entries.push(entry);
+          if (entries.length >= limit) break;
+        }
+      }
+    }
+
+    return entries;
+  }
+
+  /**
+   * Update outbox entry status
+   */
+  async updateOutboxStatus(id: string, status: OutboxEntry['status'], error?: string): Promise<void> {
+    const entry = this.db.get(`outbox:${id}`) as OutboxEntry | undefined;
+    if (entry) {
+      entry.status = status;
+      entry.lastError = error;
+      entry.attempts++;
+      if (status === 'completed') {
+        entry.processedAt = new Date().toISOString();
+      }
+    }
+  }
+}

package/packages/event-store/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@pi/event-store",
-  "version": "1.1.335",
+  "version": "1.1.337",
   "type": "module",
   "main": "src/index.ts",
   "exports": {

package/packages/experience-replay/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@pi-harness/experience-replay",
-  "version": "1.1.335",
+  "version": "1.1.337",
   "description": "Experience replay for debugging and reproducibility (RFC-0059)",
   "type": "module",
   "main": "./dist/index.js",

package/packages/feedback-collector/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@pi/feedback-collector",
-  "version": "1.1.335",
+  "version": "1.1.337",
   "type": "module",
   "description": "Collect and aggregate human/automated feedback (RFC-0021)",
   "main": "dist/index.js",

package/packages/file-copy-helper/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@moocoding/file-copy-helper",
-  "version": "1.1.335",
+  "version": "1.1.337",
   "description": "Injects cp/sudo cp rule when user asks to mimic/copy files",
   "type": "module",
   "main": "dist/index.js",