@nt-ai-lab/deterministic-agent-workflow-event-store 0.1.0

package/dist/index.d.ts

@@ -0,0 +1,4 @@
+export type { SqliteEventStore } from './platform/domain/sqlite-event-store';
+export { createStore, resolveSessionId, } from './platform/domain/sqlite-event-store';
+export type { SqliteDatabase, SqliteStatement, } from './platform/infra/external-clients/sqlite/sqlite-runtime';
+export { enableWalMode, openSqliteDatabase, } from './platform/infra/external-clients/sqlite/sqlite-runtime';

package/dist/index.js

@@ -0,0 +1,2 @@
+export { createStore, resolveSessionId, } from './platform/domain/sqlite-event-store.js';
+export { enableWalMode, openSqliteDatabase, } from './platform/infra/external-clients/sqlite/sqlite-runtime.js';

package/dist/platform/domain/sqlite-event-store.d.ts

@@ -0,0 +1,27 @@
+import { z } from 'zod';
+import { type SqliteDatabase } from '../infra/external-clients/sqlite/sqlite-runtime';
+declare const passthroughEventSchema: z.ZodObject<{
+    type: z.ZodString;
+    at: z.ZodString;
+}, "passthrough", z.ZodTypeAny, z.objectOutputType<{
+    type: z.ZodString;
+    at: z.ZodString;
+}, z.ZodTypeAny, "passthrough">, z.objectInputType<{
+    type: z.ZodString;
+    at: z.ZodString;
+}, z.ZodTypeAny, "passthrough">>;
+type BaseEvent = z.infer<typeof passthroughEventSchema>;
+/** @riviere-role value-object */
+export type SqliteEventStore = {
+    readonly readEvents: (sessionId: string) => readonly BaseEvent[];
+    readonly appendEvents: (sessionId: string, events: readonly BaseEvent[]) => void;
+    readonly sessionExists: (sessionId: string) => boolean;
+    readonly hasSessionStarted: (sessionId: string) => boolean;
+    readonly listSessions: () => readonly string[];
+    readonly db: SqliteDatabase;
+};
+/** @riviere-role domain-service */
+export declare function createStore(dbPath: string): SqliteEventStore;
+/** @riviere-role domain-service */
+export declare function resolveSessionId(store: SqliteEventStore, input: string): string;
+export {};

package/dist/platform/domain/sqlite-event-store.js

@@ -0,0 +1,103 @@
+import { z } from 'zod';
+import { WorkflowStateError } from '@nt-ai-lab/deterministic-agent-workflow-engine';
+import { enableWalMode, openSqliteDatabase, } from '../infra/external-clients/sqlite/sqlite-runtime.js';
+const passthroughEventSchema = z.object({
+    type: z.string(),
+    at: z.string(),
+}).passthrough();
+const createTableSql = `
+  CREATE TABLE IF NOT EXISTS events (
+    seq INTEGER PRIMARY KEY AUTOINCREMENT,
+    session_id TEXT NOT NULL,
+    type TEXT NOT NULL,
+    at TEXT NOT NULL,
+    payload TEXT NOT NULL
+  )
+`;
+const rowWithPayloadSchema = z.array(z.object({ payload: z.string() }));
+const rowWithSessionIdSchema = z.array(z.object({ session_id: z.string() }));
+const countFieldSchema = z.union([z.number(), z.bigint(), z.string()]);
+const countRowSchema = z.object({ count: countFieldSchema });
+/** @riviere-role domain-service */
+export function createStore(dbPath) {
+    const db = openSqliteDatabase(dbPath);
+    enableWalMode(db);
+    db.exec(createTableSql);
+    return {
+        db,
+        readEvents(sessionId) {
+            const rawRows = db.prepare('SELECT payload FROM events WHERE session_id = ? ORDER BY seq').all(sessionId);
+            const rows = rowWithPayloadSchema.parse(rawRows);
+            return rows.map((row, index) => {
+                const parsedPayload = tryParsePayload(row.payload, index);
+                const parsedEvent = passthroughEventSchema.safeParse(parsedPayload);
+                if (!parsedEvent.success) {
+                    throw new WorkflowStateError(`Invalid event at index ${index} for session ${sessionId}: ${parsedEvent.error.message}`);
+                }
+                return parsedEvent.data;
+            });
+        },
+        appendEvents(sessionId, events) {
+            if (events.length === 0)
+                return;
+            const insert = db.prepare('INSERT INTO events (session_id, type, at, payload) VALUES (?, ?, ?, ?)');
+            db.exec('BEGIN IMMEDIATE');
+            try {
+                for (const event of events) {
+                    insert.run(sessionId, event.type, event.at, JSON.stringify(event));
+                }
+                db.exec('COMMIT');
+            }
+            catch (error) {
+                db.exec('ROLLBACK');
+                throw error;
+            }
+        },
+        sessionExists(sessionId) {
+            return readCount(db, 'SELECT COUNT(1) AS count FROM events WHERE session_id = ?', sessionId) > 0;
+        },
+        hasSessionStarted(sessionId) {
+            return readCount(db, "SELECT COUNT(1) AS count FROM events WHERE session_id = ? AND type = 'session-started'", sessionId) > 0;
+        },
+        listSessions() {
+            const rawRows = db.prepare('SELECT session_id FROM events GROUP BY session_id ORDER BY MIN(seq)').all();
+            return rowWithSessionIdSchema.parse(rawRows).map((row) => row.session_id);
+        },
+    };
+}
+function readCount(db, query, sessionId) {
+    const rawRow = db.prepare(query).get(sessionId);
+    if (rawRow === undefined || rawRow === null)
+        return 0;
+    const parsed = countRowSchema.safeParse(rawRow);
+    if (!parsed.success) {
+        throw new WorkflowStateError(`Invalid count query row for session ${sessionId}: ${parsed.error.message}`);
+    }
+    const normalized = Number(parsed.data.count);
+    if (!Number.isFinite(normalized) || normalized < 0) {
+        throw new WorkflowStateError(`Invalid count value for session ${sessionId}: ${String(parsed.data.count)}`);
+    }
+    return normalized;
+}
+/** @riviere-role domain-service */
+export function resolveSessionId(store, input) {
+    if (store.sessionExists(input))
+        return input;
+    const prefixMatches = store.listSessions().filter((session) => session.startsWith(input));
+    const singleMatch = prefixMatches.length === 1 ? prefixMatches[0] : undefined;
+    if (singleMatch !== undefined)
+        return singleMatch;
+    if (prefixMatches.length > 1) {
+        const matches = prefixMatches.map((session) => `  ${session}`).join('\n');
+        throw new WorkflowStateError(`Ambiguous session prefix "${input}". Matches:\n${matches}`);
+    }
+    throw new WorkflowStateError(`No events found for session "${input}". Run "analyze --all" to list available sessions.`);
+}
+function tryParsePayload(payload, index) {
+    try {
+        return JSON.parse(payload);
+    }
+    catch (cause) {
+        throw new WorkflowStateError(`Cannot parse event payload at index ${index}: ${String(cause)}`);
+    }
+}

package/dist/platform/infra/external-clients/sqlite/sqlite-runtime.d.ts

@@ -0,0 +1,20 @@
+/** @riviere-role external-client-model */
+export type SqliteStatement = {
+    readonly all: (...params: readonly unknown[]) => readonly unknown[];
+    readonly get: (...params: readonly unknown[]) => unknown | undefined;
+    readonly run: (...params: readonly unknown[]) => unknown;
+};
+/** @riviere-role external-client-model */
+export type SqliteDatabase = {
+    readonly prepare: (sql: string) => SqliteStatement;
+    readonly exec: (sql: string) => void;
+    readonly close: () => void;
+};
+type OpenOptions = {
+    readonly readonly?: boolean;
+};
+/** @riviere-role external-client-service */
+export declare function openSqliteDatabase(path: string, options?: OpenOptions): SqliteDatabase;
+/** @riviere-role external-client-service */
+export declare function enableWalMode(database: SqliteDatabase): void;
+export {};

package/dist/platform/infra/external-clients/sqlite/sqlite-runtime.js

@@ -0,0 +1,64 @@
+import { createRequire } from 'node:module';
+const require = createRequire(import.meta.url);
+const sqliteFactory = loadSqliteFactory();
+/** @riviere-role external-client-service */
+export function openSqliteDatabase(path, options = {}) {
+    return wrapSqliteDatabase(sqliteFactory.open(path, options));
+}
+/** @riviere-role external-client-service */
+export function enableWalMode(database) {
+    database.exec('PRAGMA journal_mode = WAL');
+}
+function loadSqliteFactory() {
+    if (process.versions['bun'] !== undefined) {
+        return loadBunSqliteFactory();
+    }
+    return loadNodeSqliteFactory();
+}
+function loadBunSqliteFactory() {
+    const requiredModule = require('bun:sqlite');
+    if (!isBunSqliteModule(requiredModule)) {
+        throw new TypeError('bun:sqlite did not expose Database.');
+    }
+    return {
+        open(path, options) {
+            return options.readonly === true
+                ? new requiredModule.Database(path, { readonly: true })
+                : new requiredModule.Database(path);
+        },
+    };
+}
+function loadNodeSqliteFactory() {
+    const requiredModule = require('node:sqlite');
+    if (!isNodeSqliteModule(requiredModule)) {
+        throw new TypeError('node:sqlite did not expose DatabaseSync.');
+    }
+    return {
+        open(path, options) {
+            return new requiredModule.DatabaseSync(path, { readOnly: options.readonly === true });
+        },
+    };
+}
+function wrapSqliteDatabase(db) {
+    return {
+        prepare: (sql) => wrapSqliteStatement(db.prepare(sql)),
+        exec: (sql) => db.exec(sql),
+        close: () => db.close(),
+    };
+}
+function wrapSqliteStatement(statement) {
+    return {
+        all: (...params) => statement.all(...params),
+        get: (...params) => normalizeGetResult(statement.get(...params)),
+        run: (...params) => statement.run(...params),
+    };
+}
+function normalizeGetResult(row) {
+    return row === null ? undefined : row;
+}
+function isBunSqliteModule(value) {
+    return typeof value === 'object' && value !== null && 'Database' in value;
+}
+function isNodeSqliteModule(value) {
+    return typeof value === 'object' && value !== null && 'DatabaseSync' in value;
+}

package/package.json

@@ -0,0 +1,20 @@
+{
+  "name": "@nt-ai-lab/deterministic-agent-workflow-event-store",
+  "version": "0.1.0",
+  "private": false,
+  "type": "module",
+  "exports": {
+    ".": "./dist/index.js"
+  },
+  "types": "./dist/index.d.ts",
+  "files": [
+    "dist"
+  ],
+  "dependencies": {
+    "@nt-ai-lab/deterministic-agent-workflow-engine": "workspace:*",
+    "zod": "^3.25.76"
+  },
+  "publishConfig": {
+    "access": "public"
+  }
+}