@wopr-network/defcon 0.2.0

package/dist/src/repositories/drizzle/flow.repo.js

@@ -0,0 +1,364 @@
+import { and, eq } from "drizzle-orm";
+import { flowDefinitions, flowVersions, stateDefinitions, transitionRules } from "./schema.js";
+function toDate(v) {
+    return v != null ? new Date(v) : null;
+}
+function rowToState(r) {
+    return {
+        id: r.id,
+        flowId: r.flowId,
+        name: r.name,
+        modelTier: r.modelTier ?? null,
+        mode: (r.mode ?? "passive"),
+        promptTemplate: r.promptTemplate ?? null,
+        constraints: r.constraints,
+        onEnter: r.onEnter ?? null,
+    };
+}
+function rowToTransition(r) {
+    return {
+        id: r.id,
+        flowId: r.flowId,
+        fromState: r.fromState,
+        toState: r.toState,
+        trigger: r.trigger,
+        gateId: r.gateId ?? null,
+        condition: r.condition ?? null,
+        priority: r.priority ?? 0,
+        spawnFlow: r.spawnFlow ?? null,
+        spawnTemplate: r.spawnTemplate ?? null,
+        createdAt: toDate(r.createdAt),
+    };
+}
+function rowToFlow(r, states, transitions) {
+    return {
+        id: r.id,
+        name: r.name,
+        description: r.description ?? null,
+        entitySchema: r.entitySchema,
+        initialState: r.initialState,
+        maxConcurrent: r.maxConcurrent ?? 0,
+        maxConcurrentPerRepo: r.maxConcurrentPerRepo ?? 0,
+        affinityWindowMs: r.affinityWindowMs ?? 300000,
+        gateTimeoutMs: r.gateTimeoutMs ?? null,
+        version: r.version ?? 1,
+        createdBy: r.createdBy ?? null,
+        discipline: r.discipline ?? null,
+        defaultModelTier: r.defaultModelTier ?? null,
+        timeoutPrompt: r.timeoutPrompt ?? null,
+        createdAt: toDate(r.createdAt),
+        updatedAt: toDate(r.updatedAt),
+        states,
+        transitions,
+    };
+}
+export class DrizzleFlowRepository {
+    db;
+    constructor(db) {
+        this.db = db;
+    }
+    hydrateFlow(row) {
+        const states = this.db
+            .select()
+            .from(stateDefinitions)
+            .where(eq(stateDefinitions.flowId, row.id))
+            .all()
+            .map(rowToState);
+        const transitions = this.db
+            .select()
+            .from(transitionRules)
+            .where(eq(transitionRules.flowId, row.id))
+            .all()
+            .map(rowToTransition);
+        return rowToFlow(row, states, transitions);
+    }
+    async create(input) {
+        const now = Date.now();
+        const id = crypto.randomUUID();
+        const row = {
+            id,
+            name: input.name,
+            description: input.description ?? null,
+            entitySchema: (input.entitySchema ?? null),
+            initialState: input.initialState,
+            maxConcurrent: input.maxConcurrent ?? 0,
+            maxConcurrentPerRepo: input.maxConcurrentPerRepo ?? 0,
+            affinityWindowMs: input.affinityWindowMs ?? 300000,
+            gateTimeoutMs: input.gateTimeoutMs ?? null,
+            version: 1,
+            createdBy: input.createdBy ?? null,
+            discipline: input.discipline ?? null,
+            defaultModelTier: input.defaultModelTier ?? null,
+            timeoutPrompt: input.timeoutPrompt ?? null,
+            createdAt: now,
+            updatedAt: now,
+        };
+        this.db.insert(flowDefinitions).values(row).run();
+        return rowToFlow(row, [], []);
+    }
+    async get(id) {
+        const rows = this.db.select().from(flowDefinitions).where(eq(flowDefinitions.id, id)).all();
+        if (rows.length === 0)
+            return null;
+        return this.hydrateFlow(rows[0]);
+    }
+    async getByName(name) {
+        const rows = this.db.select().from(flowDefinitions).where(eq(flowDefinitions.name, name)).all();
+        if (rows.length === 0)
+            return null;
+        return this.hydrateFlow(rows[0]);
+    }
+    async list() {
+        const rows = this.db.select().from(flowDefinitions).all();
+        return rows.map((row) => this.hydrateFlow(row));
+    }
+    async listAll() {
+        return this.list();
+    }
+    async update(id, changes) {
+        const now = Date.now();
+        const current = this.db.select().from(flowDefinitions).where(eq(flowDefinitions.id, id)).all();
+        if (current.length === 0)
+            throw new Error(`Flow not found: ${id}`);
+        const updateValues = { updatedAt: now };
+        if (changes.name !== undefined)
+            updateValues.name = changes.name;
+        if (changes.description !== undefined)
+            updateValues.description = changes.description;
+        if (changes.entitySchema !== undefined)
+            updateValues.entitySchema = changes.entitySchema;
+        if (changes.initialState !== undefined)
+            updateValues.initialState = changes.initialState;
+        if (changes.maxConcurrent !== undefined)
+            updateValues.maxConcurrent = changes.maxConcurrent;
+        if (changes.maxConcurrentPerRepo !== undefined)
+            updateValues.maxConcurrentPerRepo = changes.maxConcurrentPerRepo;
+        if (changes.affinityWindowMs !== undefined)
+            updateValues.affinityWindowMs = changes.affinityWindowMs;
+        if (changes.gateTimeoutMs !== undefined)
+            updateValues.gateTimeoutMs = changes.gateTimeoutMs;
+        if (changes.version !== undefined)
+            updateValues.version = changes.version;
+        if (changes.createdBy !== undefined)
+            updateValues.createdBy = changes.createdBy;
+        if (changes.discipline !== undefined)
+            updateValues.discipline = changes.discipline;
+        if (changes.defaultModelTier !== undefined)
+            updateValues.defaultModelTier = changes.defaultModelTier;
+        if (changes.timeoutPrompt !== undefined)
+            updateValues.timeoutPrompt = changes.timeoutPrompt;
+        this.db.update(flowDefinitions).set(updateValues).where(eq(flowDefinitions.id, id)).run();
+        const updated = this.db.select().from(flowDefinitions).where(eq(flowDefinitions.id, id)).all();
+        return this.hydrateFlow(updated[0]);
+    }
+    async addState(flowId, state) {
+        const id = crypto.randomUUID();
+        const row = {
+            id,
+            flowId,
+            name: state.name,
+            agentRole: null,
+            modelTier: state.modelTier ?? null,
+            mode: state.mode ?? "passive",
+            promptTemplate: state.promptTemplate ?? null,
+            constraints: (state.constraints ?? null),
+            onEnter: (state.onEnter ?? null),
+        };
+        this.db.transaction((tx) => {
+            tx.insert(stateDefinitions).values(row).run();
+            tx.update(flowDefinitions).set({ updatedAt: Date.now() }).where(eq(flowDefinitions.id, flowId)).run();
+        });
+        return rowToState(row);
+    }
+    async updateState(stateId, changes) {
+        const existing = this.db.select().from(stateDefinitions).where(eq(stateDefinitions.id, stateId)).all();
+        if (existing.length === 0)
+            throw new Error(`State not found: ${stateId}`);
+        const updateValues = {};
+        if (changes.name !== undefined)
+            updateValues.name = changes.name;
+        if (changes.modelTier !== undefined)
+            updateValues.modelTier = changes.modelTier;
+        if (changes.mode !== undefined)
+            updateValues.mode = changes.mode;
+        if (changes.promptTemplate !== undefined)
+            updateValues.promptTemplate = changes.promptTemplate;
+        if (changes.constraints !== undefined)
+            updateValues.constraints = changes.constraints;
+        if (changes.onEnter !== undefined)
+            updateValues.onEnter = changes.onEnter;
+        if (Object.keys(updateValues).length > 0) {
+            this.db.update(stateDefinitions).set(updateValues).where(eq(stateDefinitions.id, stateId)).run();
+        }
+        const rows = this.db.select().from(stateDefinitions).where(eq(stateDefinitions.id, stateId)).all();
+        this.db.update(flowDefinitions).set({ updatedAt: Date.now() }).where(eq(flowDefinitions.id, rows[0].flowId)).run();
+        return rowToState(rows[0]);
+    }
+    async addTransition(flowId, transition) {
+        const now = Date.now();
+        const id = crypto.randomUUID();
+        const row = {
+            id,
+            flowId,
+            fromState: transition.fromState,
+            toState: transition.toState,
+            trigger: transition.trigger,
+            gateId: transition.gateId ?? null,
+            condition: transition.condition ?? null,
+            priority: transition.priority ?? 0,
+            spawnFlow: transition.spawnFlow ?? null,
+            spawnTemplate: transition.spawnTemplate ?? null,
+            createdAt: now,
+        };
+        this.db.transaction((tx) => {
+            tx.insert(transitionRules).values(row).run();
+            tx.update(flowDefinitions).set({ updatedAt: now }).where(eq(flowDefinitions.id, flowId)).run();
+        });
+        return rowToTransition(row);
+    }
+    async updateTransition(transitionId, changes) {
+        const existing = this.db.select().from(transitionRules).where(eq(transitionRules.id, transitionId)).all();
+        if (existing.length === 0)
+            throw new Error(`Transition not found: ${transitionId}`);
+        const updateValues = {};
+        if (changes.fromState !== undefined)
+            updateValues.fromState = changes.fromState;
+        if (changes.toState !== undefined)
+            updateValues.toState = changes.toState;
+        if (changes.trigger !== undefined)
+            updateValues.trigger = changes.trigger;
+        if (changes.gateId !== undefined)
+            updateValues.gateId = changes.gateId;
+        if (changes.condition !== undefined)
+            updateValues.condition = changes.condition;
+        if (changes.priority !== undefined)
+            updateValues.priority = changes.priority;
+        if (changes.spawnFlow !== undefined)
+            updateValues.spawnFlow = changes.spawnFlow;
+        if (changes.spawnTemplate !== undefined)
+            updateValues.spawnTemplate = changes.spawnTemplate;
+        if (Object.keys(updateValues).length > 0) {
+            this.db.update(transitionRules).set(updateValues).where(eq(transitionRules.id, transitionId)).run();
+        }
+        const rows = this.db.select().from(transitionRules).where(eq(transitionRules.id, transitionId)).all();
+        this.db.update(flowDefinitions).set({ updatedAt: Date.now() }).where(eq(flowDefinitions.id, rows[0].flowId)).run();
+        return rowToTransition(rows[0]);
+    }
+    async snapshot(flowId) {
+        const flow = await this.get(flowId);
+        if (!flow)
+            throw new Error(`Flow not found: ${flowId}`);
+        const now = Date.now();
+        const id = crypto.randomUUID();
+        const snapshotData = {
+            id: flow.id,
+            name: flow.name,
+            description: flow.description,
+            entitySchema: flow.entitySchema,
+            initialState: flow.initialState,
+            maxConcurrent: flow.maxConcurrent,
+            maxConcurrentPerRepo: flow.maxConcurrentPerRepo,
+            affinityWindowMs: flow.affinityWindowMs,
+            gateTimeoutMs: flow.gateTimeoutMs,
+            version: flow.version,
+            createdBy: flow.createdBy,
+            timeoutPrompt: flow.timeoutPrompt,
+            createdAt: flow.createdAt,
+            updatedAt: flow.updatedAt,
+            discipline: flow.discipline,
+            defaultModelTier: flow.defaultModelTier,
+            states: flow.states,
+            transitions: flow.transitions,
+        };
+        const nextVersion = this.db.transaction((tx) => {
+            const existing = tx.select().from(flowVersions).where(eq(flowVersions.flowId, flowId)).all();
+            const maxVersion = existing.reduce((max, r) => Math.max(max, r.version), 0);
+            const version = maxVersion + 1;
+            tx.insert(flowVersions)
+                .values({
+                id,
+                flowId,
+                version,
+                snapshot: snapshotData,
+                changedBy: null,
+                changeReason: null,
+                createdAt: now,
+            })
+                .run();
+            return version;
+        });
+        return {
+            id,
+            flowId,
+            version: nextVersion,
+            snapshot: snapshotData,
+            changedBy: null,
+            changeReason: null,
+            createdAt: new Date(now),
+        };
+    }
+    async restore(flowId, version) {
+        const versionRows = this.db
+            .select()
+            .from(flowVersions)
+            .where(and(eq(flowVersions.flowId, flowId), eq(flowVersions.version, version)))
+            .all();
+        if (versionRows.length === 0)
+            throw new Error(`Version ${version} not found for flow ${flowId}`);
+        const snap = versionRows[0].snapshot;
+        this.db.transaction((tx) => {
+            tx.delete(transitionRules).where(eq(transitionRules.flowId, flowId)).run();
+            tx.delete(stateDefinitions).where(eq(stateDefinitions.flowId, flowId)).run();
+            for (const s of snap.states) {
+                tx.insert(stateDefinitions)
+                    .values({
+                    id: s.id,
+                    flowId,
+                    name: s.name,
+                    modelTier: s.modelTier,
+                    mode: s.mode ?? "passive",
+                    promptTemplate: s.promptTemplate,
+                    constraints: s.constraints,
+                    onEnter: (s.onEnter ?? null),
+                })
+                    .run();
+            }
+            for (const t of snap.transitions) {
+                tx.insert(transitionRules)
+                    .values({
+                    id: t.id,
+                    flowId,
+                    fromState: t.fromState,
+                    toState: t.toState,
+                    trigger: t.trigger,
+                    gateId: t.gateId,
+                    condition: t.condition,
+                    priority: t.priority ?? 0,
+                    spawnFlow: t.spawnFlow,
+                    spawnTemplate: t.spawnTemplate,
+                    createdAt: t.createdAt ? new Date(t.createdAt).getTime() : null,
+                })
+                    .run();
+            }
+            tx.update(flowDefinitions)
+                .set({
+                name: snap.name,
+                description: snap.description,
+                entitySchema: snap.entitySchema,
+                initialState: snap.initialState,
+                maxConcurrent: snap.maxConcurrent,
+                maxConcurrentPerRepo: snap.maxConcurrentPerRepo,
+                affinityWindowMs: snap.affinityWindowMs,
+                gateTimeoutMs: snap.gateTimeoutMs ?? null,
+                version: snap.version,
+                createdBy: snap.createdBy,
+                discipline: snap.discipline,
+                defaultModelTier: snap.defaultModelTier ?? null,
+                timeoutPrompt: snap.timeoutPrompt,
+                updatedAt: Date.now(),
+            })
+                .where(eq(flowDefinitions.id, flowId))
+                .run();
+        });
+    }
+}

package/dist/src/repositories/drizzle/gate.repo.d.ts

@@ -0,0 +1,16 @@
+import type { BetterSQLite3Database } from "drizzle-orm/better-sqlite3";
+import type { CreateGateInput, Gate, GateResult, IGateRepository } from "../interfaces.js";
+import type * as schema from "./schema.js";
+type Db = BetterSQLite3Database<typeof schema>;
+export declare class DrizzleGateRepository implements IGateRepository {
+    private db;
+    constructor(db: Db);
+    create(gate: CreateGateInput): Promise<Gate>;
+    get(id: string): Promise<Gate | null>;
+    getByName(name: string): Promise<Gate | null>;
+    listAll(): Promise<Gate[]>;
+    record(entityId: string, gateId: string, passed: boolean, output: string): Promise<GateResult>;
+    update(id: string, changes: Partial<Pick<Gate, "command" | "functionRef" | "apiConfig" | "timeoutMs" | "failurePrompt" | "timeoutPrompt">>): Promise<Gate>;
+    resultsFor(entityId: string): Promise<GateResult[]>;
+}
+export {};

package/dist/src/repositories/drizzle/gate.repo.js

@@ -0,0 +1,98 @@
+import { randomUUID } from "node:crypto";
+import { asc, eq, sql } from "drizzle-orm";
+import { gateDefinitions, gateResults } from "./schema.js";
+function toGate(row) {
+    return {
+        id: row.id,
+        name: row.name,
+        type: row.type,
+        command: row.command,
+        functionRef: row.functionRef,
+        apiConfig: row.apiConfig,
+        timeoutMs: row.timeoutMs ?? null,
+        failurePrompt: row.failurePrompt ?? null,
+        timeoutPrompt: row.timeoutPrompt ?? null,
+    };
+}
+function toGateResult(row) {
+    return {
+        id: row.id,
+        entityId: row.entityId,
+        gateId: row.gateId,
+        passed: !!row.passed,
+        output: row.output,
+        evaluatedAt: row.evaluatedAt != null ? new Date(row.evaluatedAt) : null,
+    };
+}
+export class DrizzleGateRepository {
+    db;
+    constructor(db) {
+        this.db = db;
+    }
+    async create(gate) {
+        const id = randomUUID();
+        const values = {
+            id,
+            name: gate.name,
+            type: gate.type,
+            command: gate.command ?? null,
+            functionRef: gate.functionRef ?? null,
+            apiConfig: gate.apiConfig ?? null,
+            ...(gate.timeoutMs != null ? { timeoutMs: gate.timeoutMs } : {}),
+            failurePrompt: gate.failurePrompt ?? null,
+            timeoutPrompt: gate.timeoutPrompt ?? null,
+        };
+        this.db.insert(gateDefinitions).values(values).run();
+        const row = this.db.select().from(gateDefinitions).where(eq(gateDefinitions.id, id)).get();
+        if (!row)
+            throw new Error(`Gate ${id} not found after insert`);
+        return toGate(row);
+    }
+    async get(id) {
+        const row = this.db.select().from(gateDefinitions).where(eq(gateDefinitions.id, id)).get();
+        return row ? toGate(row) : null;
+    }
+    async getByName(name) {
+        const row = this.db.select().from(gateDefinitions).where(eq(gateDefinitions.name, name)).get();
+        return row ? toGate(row) : null;
+    }
+    async listAll() {
+        const rows = this.db.select().from(gateDefinitions).all();
+        return rows.map(toGate);
+    }
+    async record(entityId, gateId, passed, output) {
+        const id = randomUUID();
+        const evaluatedAt = Date.now();
+        this.db
+            .insert(gateResults)
+            .values({
+            id,
+            entityId,
+            gateId,
+            passed: passed ? 1 : 0,
+            output,
+            evaluatedAt,
+        })
+            .run();
+        const row = this.db.select().from(gateResults).where(eq(gateResults.id, id)).get();
+        if (!row)
+            throw new Error(`GateResult ${id} not found after insert`);
+        return toGateResult(row);
+    }
+    async update(id, changes) {
+        this.db.update(gateDefinitions).set(changes).where(eq(gateDefinitions.id, id)).run();
+        const row = this.db.select().from(gateDefinitions).where(eq(gateDefinitions.id, id)).get();
+        if (!row)
+            throw new Error(`Gate ${id} not found after update`);
+        return toGate(row);
+    }
+    async resultsFor(entityId) {
+        const rows = this.db
+            .select()
+            .from(gateResults)
+            .where(eq(gateResults.entityId, entityId))
+            .orderBy(asc(gateResults.evaluatedAt), sql `rowid`)
+            .all();
+        return rows.map(toGateResult);
+    }
+}

package/dist/src/repositories/drizzle/index.d.ts

@@ -0,0 +1,6 @@
+export { DrizzleEntityRepository } from "./entity.repo.js";
+export { DrizzleEventRepository } from "./event.repo.js";
+export { DrizzleFlowRepository } from "./flow.repo.js";
+export { DrizzleGateRepository } from "./gate.repo.js";
+export { DrizzleInvocationRepository } from "./invocation.repo.js";
+export { DrizzleTransitionLogRepository } from "./transition-log.repo.js";

package/dist/src/repositories/drizzle/index.js

@@ -0,0 +1,7 @@
+// Drizzle ORM implementations of repository interfaces
+export { DrizzleEntityRepository } from "./entity.repo.js";
+export { DrizzleEventRepository } from "./event.repo.js";
+export { DrizzleFlowRepository } from "./flow.repo.js";
+export { DrizzleGateRepository } from "./gate.repo.js";
+export { DrizzleInvocationRepository } from "./invocation.repo.js";
+export { DrizzleTransitionLogRepository } from "./transition-log.repo.js";

package/dist/src/repositories/drizzle/invocation.repo.d.ts

@@ -0,0 +1,23 @@
+import type { BetterSQLite3Database } from "drizzle-orm/better-sqlite3";
+import type { Artifacts, IInvocationRepository, Invocation, Mode } from "../interfaces.js";
+import type * as schema from "./schema.js";
+type Db = BetterSQLite3Database<typeof schema>;
+export declare class DrizzleInvocationRepository implements IInvocationRepository {
+    private db;
+    constructor(db: Db);
+    create(entityId: string, stage: string, prompt: string, mode: Mode, ttlMs?: number, context?: Record<string, unknown>): Promise<Invocation>;
+    get(id: string): Promise<Invocation | null>;
+    claim(invocationId: string, agentId: string): Promise<Invocation | null>;
+    complete(id: string, signal: string, artifacts?: Artifacts): Promise<Invocation>;
+    fail(id: string, error: string): Promise<Invocation>;
+    releaseClaim(id: string): Promise<void>;
+    findByEntity(entityId: string): Promise<Invocation[]>;
+    findUnclaimedWithAffinity(flowId: string, role: string, workerId: string): Promise<Invocation[]>;
+    findUnclaimedByFlow(flowId: string): Promise<Invocation[]>;
+    findByFlow(flowId: string): Promise<Invocation[]>;
+    findUnclaimedActive(flowId?: string): Promise<Invocation[]>;
+    countActiveByFlow(flowId: string): Promise<number>;
+    countPendingByFlow(flowId: string): Promise<number>;
+    reapExpired(): Promise<Invocation[]>;
+}
+export {};