@wopr-network/defcon 0.2.0 → 0.2.2

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

@@ -1,364 +0,0 @@
-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/repositories/drizzle/gate.repo.d.ts

@@ -1,16 +0,0 @@
-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/repositories/drizzle/gate.repo.js

@@ -1,98 +0,0 @@
-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/repositories/drizzle/index.d.ts

@@ -1,6 +0,0 @@
-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/repositories/drizzle/index.js

@@ -1,7 +0,0 @@
-// 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/repositories/drizzle/invocation.repo.d.ts

@@ -1,23 +0,0 @@
-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 {};