@wopr-network/defcon 0.2.0 → 0.2.2

package/dist/execution/provision-worktree.d.ts

@@ -1,16 +0,0 @@
-export interface ProvisionWorktreeResult {
-    worktreePath: string;
-    branch: string;
-    repo: string;
-}
-export declare function parseIssueNumber(issueKey: string): string;
-export declare function repoName(repo: string): string;
-export declare function validateRepoName(name: string): string;
-export declare function buildBranch(issueKey: string): string;
-export declare function buildWorktreePath(repo: string, issueKey: string, basePath: string): string;
-export declare function provisionWorktree(opts: {
-    repo: string;
-    issueKey: string;
-    basePath?: string;
-    cloneRoot?: string;
-}): ProvisionWorktreeResult;

package/dist/execution/provision-worktree.js

@@ -1,123 +0,0 @@
-import { execFileSync } from "node:child_process";
-import { existsSync } from "node:fs";
-import { homedir } from "node:os";
-import { join, resolve } from "node:path";
-export function parseIssueNumber(issueKey) {
-    const match = issueKey.match(/^[A-Za-z]+[-](\d+)$/);
-    if (!match) {
-        throw new Error(`Invalid issue key: ${issueKey}. Expected format: WOP-123`);
-    }
-    return match[1];
-}
-export function repoName(repo) {
-    const parts = repo.replace(/\/$/, "").split("/");
-    return parts[parts.length - 1] || repo;
-}
-export function validateRepoName(name) {
-    if (!/^[a-zA-Z0-9._-]+$/.test(name)) {
-        throw new Error(`Invalid repo name: ${name}`);
-    }
-    if (name === "." || name === "..") {
-        throw new Error(`Invalid repo name: ${name}`);
-    }
-    return name;
-}
-export function buildBranch(issueKey) {
-    const num = parseIssueNumber(issueKey);
-    return `agent/coder-${num}/${issueKey.toLowerCase()}`;
-}
-export function buildWorktreePath(repo, issueKey, basePath) {
-    const name = repoName(repo);
-    const num = parseIssueNumber(issueKey);
-    return join(basePath, `wopr-${name}-coder-${num}`);
-}
-function run(cmd, args, cwd) {
-    try {
-        return execFileSync(cmd, args, {
-            cwd,
-            encoding: "utf-8",
-            stdio: ["pipe", "pipe", "pipe"],
-        }).trim();
-    }
-    catch (err) {
-        const e = err;
-        throw new Error(`${cmd} ${args.join(" ")} failed: ${e.stderr ?? e.message ?? String(err)}`);
-    }
-}
-export function provisionWorktree(opts) {
-    const basePath = opts.basePath ?? join(homedir(), "worktrees");
-    const cloneRoot = opts.cloneRoot ?? homedir();
-    const name = validateRepoName(repoName(opts.repo));
-    const clonePath = join(cloneRoot, name);
-    if (!resolve(clonePath).startsWith(`${resolve(cloneRoot)}/`) && resolve(clonePath) !== resolve(cloneRoot)) {
-        throw new Error(`Repo name escapes cloneRoot: ${name}`);
-    }
-    const worktreePath = buildWorktreePath(opts.repo, opts.issueKey, basePath);
-    const branch = buildBranch(opts.issueKey);
-    // Idempotent: if worktree already exists, verify and return
-    if (existsSync(worktreePath)) {
-        try {
-            run("git", ["rev-parse", "--git-dir"], worktreePath);
-            const currentBranch = run("git", ["rev-parse", "--abbrev-ref", "HEAD"], worktreePath);
-            if (currentBranch !== branch) {
-                throw new Error(`Worktree at ${worktreePath} is on branch ${currentBranch}, expected ${branch}`);
-            }
-            const remoteUrl = run("git", ["remote", "get-url", "origin"], worktreePath);
-            const repoPath = opts.repo.replace(/\.git$/, "");
-            const urlMatchesRepo = remoteUrl.endsWith(`/${repoPath}`) ||
-                remoteUrl.endsWith(`/${repoPath}.git`) ||
-                remoteUrl.endsWith(`:${repoPath}`) ||
-                remoteUrl.endsWith(`:${repoPath}.git`);
-            if (!urlMatchesRepo) {
-                throw new Error(`Worktree at ${worktreePath} has unexpected remote: ${remoteUrl} (expected to contain ${opts.repo})`);
-            }
-            return { worktreePath, branch, repo: opts.repo };
-        }
-        catch (err) {
-            if (err instanceof Error && err.message.startsWith("Worktree at")) {
-                throw err;
-            }
-            throw new Error(`Path ${worktreePath} exists but is not a git worktree`);
-        }
-    }
-    // Clone if repo not present
-    if (!existsSync(clonePath)) {
-        const cloneUrl = `https://github.com/${opts.repo}.git`;
-        process.stderr.write(`Cloning ${cloneUrl} to ${clonePath}...\n`);
-        run("git", ["clone", cloneUrl, clonePath]);
-    }
-    // Fetch latest
-    process.stderr.write(`Fetching origin in ${clonePath}...\n`);
-    run("git", ["fetch", "origin"], clonePath);
-    // Create worktree
-    process.stderr.write(`Creating worktree at ${worktreePath}...\n`);
-    const defaultBranchRef = run("git", ["symbolic-ref", "refs/remotes/origin/HEAD", "--short"], clonePath);
-    const defaultBranch = defaultBranchRef.replace("origin/", "");
-    try {
-        run("git", ["worktree", "add", worktreePath, "-b", branch, `origin/${defaultBranch}`], clonePath);
-    }
-    catch (err) {
-        // Branch may already exist — check if a worktree with the right branch is now present
-        if (existsSync(worktreePath)) {
-            try {
-                run("git", ["rev-parse", "--git-dir"], worktreePath);
-                const currentBranch = run("git", ["rev-parse", "--abbrev-ref", "HEAD"], worktreePath);
-                if (currentBranch === branch) {
-                    // Worktree already exists on the correct branch — idempotent success
-                    return { worktreePath, branch, repo: opts.repo };
-                }
-            }
-            catch {
-                // fall through to rethrow original error
-            }
-        }
-        throw err;
-    }
-    // Install dependencies
-    const hasPnpmLock = existsSync(join(worktreePath, "pnpm-lock.yaml"));
-    const hasYarnLock = existsSync(join(worktreePath, "yarn.lock"));
-    const installCmd = hasPnpmLock ? "pnpm" : hasYarnLock ? "yarn" : "npm";
-    process.stderr.write(`Running ${installCmd} install in ${worktreePath}...\n`);
-    execFileSync(installCmd, ["install"], { cwd: worktreePath, stdio: "inherit" });
-    return { worktreePath, branch, repo: opts.repo };
-}

package/dist/execution/tool-schemas.d.ts

@@ -1,40 +0,0 @@
-import { z } from "zod/v4";
-export declare const FlowClaimSchema: z.ZodObject<{
-    worker_id: z.ZodOptional<z.ZodString>;
-    role: z.ZodString;
-    flow: z.ZodOptional<z.ZodString>;
-}, z.core.$strip>;
-export declare const FlowGetPromptSchema: z.ZodObject<{
-    entity_id: z.ZodString;
-}, z.core.$strip>;
-export declare const FlowReportSchema: z.ZodObject<{
-    entity_id: z.ZodString;
-    signal: z.ZodString;
-    artifacts: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
-    worker_id: z.ZodOptional<z.ZodString>;
-}, z.core.$strip>;
-export declare const FlowFailSchema: z.ZodObject<{
-    entity_id: z.ZodString;
-    error: z.ZodString;
-}, z.core.$strip>;
-export declare const QueryEntitySchema: z.ZodObject<{
-    id: z.ZodString;
-}, z.core.$strip>;
-export declare const QueryEntitiesSchema: z.ZodObject<{
-    flow: z.ZodString;
-    state: z.ZodString;
-    limit: z.ZodOptional<z.ZodCoercedNumber<unknown>>;
-}, z.core.$strip>;
-export declare const QueryInvocationsSchema: z.ZodObject<{
-    entity_id: z.ZodString;
-}, z.core.$strip>;
-export declare const QueryFlowSchema: z.ZodObject<{
-    name: z.ZodString;
-}, z.core.$strip>;
-export declare const FlowSeedSchema: z.ZodObject<{
-    flow: z.ZodString;
-    refs: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodObject<{
-        adapter: z.ZodString;
-        id: z.ZodString;
-    }, z.core.$loose>>>;
-}, z.core.$strip>;

package/dist/execution/tool-schemas.js

@@ -1,44 +0,0 @@
-import { z } from "zod/v4";
-export const FlowClaimSchema = z.object({
-    worker_id: z.string().min(1).optional(),
-    role: z.string().min(1),
-    flow: z.string().min(1).optional(),
-});
-export const FlowGetPromptSchema = z.object({
-    entity_id: z.string().min(1),
-});
-export const FlowReportSchema = z.object({
-    entity_id: z.string().min(1),
-    signal: z.string().min(1),
-    artifacts: z.record(z.string(), z.unknown()).optional(),
-    worker_id: z.string().min(1).optional(),
-});
-export const FlowFailSchema = z.object({
-    entity_id: z.string().min(1),
-    error: z.string().min(1),
-});
-export const QueryEntitySchema = z.object({
-    id: z.string().min(1),
-});
-export const QueryEntitiesSchema = z.object({
-    flow: z.string().min(1),
-    state: z.string().min(1),
-    limit: z.coerce.number().int().min(1).max(100).optional(),
-});
-export const QueryInvocationsSchema = z.object({
-    entity_id: z.string().min(1),
-});
-export const QueryFlowSchema = z.object({
-    name: z.string().min(1),
-});
-export const FlowSeedSchema = z.object({
-    flow: z.string().min(1),
-    refs: z
-        .record(z.string(), z
-        .object({
-        adapter: z.string().min(1),
-        id: z.string().min(1),
-    })
-        .passthrough())
-        .optional(),
-});

package/dist/logger.d.ts

@@ -1,8 +0,0 @@
-export interface Logger {
-    error(msg: string, ...args: unknown[]): void;
-    warn(msg: string, ...args: unknown[]): void;
-    info(msg: string, ...args: unknown[]): void;
-    debug(msg: string, ...args: unknown[]): void;
-}
-export declare const consoleLogger: Logger;
-export declare const noopLogger: Logger;

package/dist/logger.js

@@ -1,12 +0,0 @@
-export const consoleLogger = {
-    error: (msg, ...args) => console.error(msg, ...args),
-    warn: (msg, ...args) => console.warn(msg, ...args),
-    info: (msg, ...args) => console.info(msg, ...args),
-    debug: (msg, ...args) => console.debug(msg, ...args),
-};
-export const noopLogger = {
-    error: () => { },
-    warn: () => { },
-    info: () => { },
-    debug: () => { },
-};

package/dist/main.d.ts

@@ -1,14 +0,0 @@
-import Database from "better-sqlite3";
-import { drizzle } from "drizzle-orm/better-sqlite3";
-import * as schema from "./repositories/drizzle/schema.js";
-export declare function createDatabase(dbPath?: string): {
-    db: ReturnType<typeof drizzle<typeof schema>>;
-    sqlite: Database.Database;
-};
-export declare function runMigrations(db: ReturnType<typeof drizzle>, migrationsFolder?: string): void;
-export declare function bootstrap(dbPath?: string): {
-    db: ReturnType<typeof drizzle>;
-    sqlite: Database.Database;
-};
-export * from "./api/wire-types.js";
-export * from "./engine/index.js";

package/dist/main.js

@@ -1,28 +0,0 @@
-import Database from "better-sqlite3";
-import { drizzle } from "drizzle-orm/better-sqlite3";
-import { migrate } from "drizzle-orm/better-sqlite3/migrator";
-import { DB_PATH } from "./config/db-path.js";
-import * as schema from "./repositories/drizzle/schema.js";
-export function createDatabase(dbPath = DB_PATH) {
-    const sqlite = new Database(dbPath);
-    sqlite.pragma("journal_mode = WAL");
-    sqlite.pragma("foreign_keys = ON");
-    const db = drizzle(sqlite, { schema });
-    return { db, sqlite };
-}
-export function runMigrations(db, migrationsFolder = "./drizzle") {
-    migrate(db, { migrationsFolder });
-}
-export function bootstrap(dbPath = DB_PATH) {
-    const { db, sqlite } = createDatabase(dbPath);
-    try {
-        runMigrations(db);
-    }
-    catch (err) {
-        sqlite.close();
-        throw err;
-    }
-    return { db, sqlite };
-}
-export * from "./api/wire-types.js";
-export * from "./engine/index.js";

package/dist/repositories/drizzle/entity.repo.d.ts

@@ -1,27 +0,0 @@
-import type { BetterSQLite3Database } from "drizzle-orm/better-sqlite3";
-import type { Artifacts, Entity, IEntityRepository, Refs } from "../interfaces.js";
-import type * as schema from "./schema.js";
-type Db = BetterSQLite3Database<typeof schema>;
-export declare class DrizzleEntityRepository implements IEntityRepository {
-    private db;
-    constructor(db: Db);
-    private toEntity;
-    create(flowId: string, initialState: string, refs?: Refs): Promise<Entity>;
-    get(id: string): Promise<Entity | null>;
-    findByFlowAndState(flowId: string, state: string, limit?: number): Promise<Entity[]>;
-    hasAnyInFlowAndState(flowId: string, stateNames: string[]): Promise<boolean>;
-    transition(id: string, toState: string, _trigger: string, artifacts?: Partial<Artifacts>, _invocationId?: string | null): Promise<Entity>;
-    updateArtifacts(id: string, artifacts: Partial<Artifacts>): Promise<void>;
-    claim(flowId: string, state: string, agentId: string): Promise<Entity | null>;
-    claimById(entityId: string, agentId: string): Promise<Entity | null>;
-    release(entityId: string, agentId: string): Promise<void>;
-    appendSpawnedChild(parentId: string, entry: {
-        childId: string;
-        childFlow: string;
-        spawnedAt: string;
-    }): Promise<void>;
-    reapExpired(ttlMs: number): Promise<string[]>;
-    setAffinity(entityId: string, workerId: string, role: string, expiresAt: Date): Promise<void>;
-    clearExpiredAffinity(): Promise<string[]>;
-}
-export {};

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

@@ -1,190 +0,0 @@
-import { and, eq, inArray, isNull, lt, not } from "drizzle-orm";
-import { entities } from "./schema.js";
-export class DrizzleEntityRepository {
-    db;
-    constructor(db) {
-        this.db = db;
-    }
-    toEntity(row) {
-        return {
-            id: row.id,
-            flowId: row.flowId,
-            state: row.state,
-            refs: row.refs,
-            artifacts: row.artifacts,
-            claimedBy: row.claimedBy,
-            claimedAt: row.claimedAt ? new Date(row.claimedAt) : null,
-            flowVersion: row.flowVersion ?? 1,
-            priority: row.priority ?? 0,
-            createdAt: new Date(row.createdAt ?? 0),
-            updatedAt: new Date(row.updatedAt ?? 0),
-            affinityWorkerId: row.affinityWorkerId ?? null,
-            affinityRole: row.affinityRole ?? null,
-            affinityExpiresAt: row.affinityExpiresAt ? new Date(row.affinityExpiresAt) : null,
-        };
-    }
-    async create(flowId, initialState, refs) {
-        const now = Date.now();
-        const id = crypto.randomUUID();
-        const row = {
-            id,
-            flowId,
-            state: initialState,
-            refs: refs ?? null,
-            artifacts: null,
-            claimedBy: null,
-            claimedAt: null,
-            flowVersion: 1,
-            createdAt: now,
-            updatedAt: now,
-            affinityWorkerId: null,
-            affinityRole: null,
-            affinityExpiresAt: null,
-        };
-        await this.db.insert(entities).values(row);
-        return this.toEntity(row);
-    }
-    async get(id) {
-        const rows = await this.db.select().from(entities).where(eq(entities.id, id)).limit(1);
-        return rows.length > 0 ? this.toEntity(rows[0]) : null;
-    }
-    async findByFlowAndState(flowId, state, limit) {
-        const query = this.db
-            .select()
-            .from(entities)
-            .where(and(eq(entities.flowId, flowId), eq(entities.state, state)));
-        const rows = await (limit !== undefined ? query.limit(limit) : query);
-        return rows.map((r) => this.toEntity(r));
-    }
-    async hasAnyInFlowAndState(flowId, stateNames) {
-        if (stateNames.length === 0)
-            return false;
-        const rows = await this.db
-            .select({ id: entities.id })
-            .from(entities)
-            .where(and(eq(entities.flowId, flowId), inArray(entities.state, stateNames)))
-            .limit(1);
-        return rows.length > 0;
-    }
-    async transition(id, toState, _trigger, artifacts, _invocationId) {
-        return this.db.transaction((tx) => {
-            const rows = tx.select().from(entities).where(eq(entities.id, id)).limit(1).all();
-            if (rows.length === 0)
-                throw new Error(`Entity not found: ${id}`);
-            const row = rows[0];
-            const now = Date.now();
-            const mergedArtifacts = artifacts
-                ? { ...(row.artifacts ?? {}), ...artifacts }
-                : row.artifacts;
-            tx.update(entities)
-                .set({ state: toState, artifacts: mergedArtifacts, updatedAt: now })
-                .where(eq(entities.id, id))
-                .run();
-            return this.toEntity({
-                ...row,
-                state: toState,
-                artifacts: mergedArtifacts,
-                updatedAt: now,
-            });
-        });
-    }
-    async updateArtifacts(id, artifacts) {
-        const rows = await this.db.select().from(entities).where(eq(entities.id, id)).limit(1);
-        if (rows.length === 0)
-            throw new Error(`Entity not found: ${id}`);
-        const existing = rows[0].artifacts ?? {};
-        await this.db
-            .update(entities)
-            .set({ artifacts: { ...existing, ...artifacts }, updatedAt: Date.now() })
-            .where(eq(entities.id, id));
-    }
-    async claim(flowId, state, agentId) {
-        return this.db.transaction((tx) => {
-            const rows = tx
-                .select()
-                .from(entities)
-                .where(and(eq(entities.flowId, flowId), eq(entities.state, state), isNull(entities.claimedBy)))
-                .limit(1)
-                .all();
-            if (rows.length === 0)
-                return null;
-            const row = rows[0];
-            const now = Date.now();
-            tx.update(entities)
-                .set({ claimedBy: agentId, claimedAt: now, updatedAt: now })
-                .where(eq(entities.id, row.id))
-                .run();
-            return this.toEntity({
-                ...row,
-                claimedBy: agentId,
-                claimedAt: now,
-                updatedAt: now,
-            });
-        });
-    }
-    async claimById(entityId, agentId) {
-        const now = Date.now();
-        const result = this.db
-            .update(entities)
-            .set({ claimedBy: agentId, claimedAt: now, updatedAt: now })
-            .where(and(eq(entities.id, entityId), isNull(entities.claimedBy)))
-            .run();
-        if (result.changes === 0)
-            return null;
-        const rows = this.db.select().from(entities).where(eq(entities.id, entityId)).limit(1).all();
-        return rows.length > 0 ? this.toEntity(rows[0]) : null;
-    }
-    async release(entityId, agentId) {
-        await this.db
-            .update(entities)
-            .set({ claimedBy: null, claimedAt: null, updatedAt: Date.now() })
-            .where(and(eq(entities.id, entityId), eq(entities.claimedBy, agentId)))
-            .run();
-    }
-    async appendSpawnedChild(parentId, entry) {
-        this.db.transaction((tx) => {
-            const rows = tx.select().from(entities).where(eq(entities.id, parentId)).limit(1).all();
-            if (rows.length === 0)
-                throw new Error(`Entity ${parentId} not found`);
-            const row = rows[0];
-            const artifacts = row.artifacts ?? {};
-            const existing = (Array.isArray(artifacts.spawnedChildren) ? artifacts.spawnedChildren : []);
-            tx.update(entities)
-                .set({ artifacts: { ...artifacts, spawnedChildren: [...existing, entry] }, updatedAt: Date.now() })
-                .where(eq(entities.id, parentId))
-                .run();
-        });
-    }
-    async reapExpired(ttlMs) {
-        const cutoff = Date.now() - ttlMs;
-        const rows = this.db
-            .update(entities)
-            .set({ claimedBy: null, claimedAt: null, updatedAt: Date.now() })
-            .where(and(not(isNull(entities.claimedBy)), lt(entities.claimedAt, cutoff)))
-            .returning({ id: entities.id })
-            .all();
-        return rows.map((r) => r.id);
-    }
-    async setAffinity(entityId, workerId, role, expiresAt) {
-        await this.db
-            .update(entities)
-            .set({
-            affinityWorkerId: workerId,
-            affinityRole: role,
-            affinityExpiresAt: expiresAt.getTime(),
-            updatedAt: Date.now(),
-        })
-            .where(eq(entities.id, entityId))
-            .run();
-    }
-    async clearExpiredAffinity() {
-        const now = Date.now();
-        const rows = this.db
-            .update(entities)
-            .set({ affinityWorkerId: null, affinityRole: null, affinityExpiresAt: null, updatedAt: now })
-            .where(and(not(isNull(entities.affinityWorkerId)), lt(entities.affinityExpiresAt, now)))
-            .returning({ id: entities.id })
-            .all();
-        return rows.map((r) => r.id);
-    }
-}

package/dist/repositories/drizzle/event.repo.d.ts

@@ -1,12 +0,0 @@
-import type { BetterSQLite3Database } from "drizzle-orm/better-sqlite3";
-import type { IEventRepository } from "../interfaces.js";
-import type * as schema from "./schema.js";
-import { events } from "./schema.js";
-type Db = BetterSQLite3Database<typeof schema>;
-export declare class DrizzleEventRepository implements IEventRepository {
-    private readonly db;
-    constructor(db: Db);
-    emitDefinitionChanged(flowId: string | null, tool: string, payload: Record<string, unknown>): Promise<void>;
-    findAll(): (typeof events.$inferSelect)[];
-}
-export {};

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

@@ -1,24 +0,0 @@
-import { randomUUID } from "node:crypto";
-import { events } from "./schema.js";
-export class DrizzleEventRepository {
-    db;
-    constructor(db) {
-        this.db = db;
-    }
-    async emitDefinitionChanged(flowId, tool, payload) {
-        this.db
-            .insert(events)
-            .values({
-            id: randomUUID(),
-            type: "definition.changed",
-            entityId: null,
-            flowId: flowId || null,
-            payload: { tool, ...payload },
-            emittedAt: Date.now(),
-        })
-            .run();
-    }
-    findAll() {
-        return this.db.select().from(events).all();
-    }
-}

package/dist/repositories/drizzle/flow.repo.d.ts

@@ -1,22 +0,0 @@
-import type { BetterSQLite3Database } from "drizzle-orm/better-sqlite3";
-import type { CreateFlowInput, CreateStateInput, CreateTransitionInput, Flow, FlowVersion, IFlowRepository, State, Transition, UpdateFlowInput, UpdateStateInput, UpdateTransitionInput } from "../interfaces.js";
-import type * as schema from "./schema.js";
-type Db = BetterSQLite3Database<typeof schema>;
-export declare class DrizzleFlowRepository implements IFlowRepository {
-    private db;
-    constructor(db: Db);
-    private hydrateFlow;
-    create(input: CreateFlowInput): Promise<Flow>;
-    get(id: string): Promise<Flow | null>;
-    getByName(name: string): Promise<Flow | null>;
-    list(): Promise<Flow[]>;
-    listAll(): Promise<Flow[]>;
-    update(id: string, changes: UpdateFlowInput): Promise<Flow>;
-    addState(flowId: string, state: CreateStateInput): Promise<State>;
-    updateState(stateId: string, changes: UpdateStateInput): Promise<State>;
-    addTransition(flowId: string, transition: CreateTransitionInput): Promise<Transition>;
-    updateTransition(transitionId: string, changes: UpdateTransitionInput): Promise<Transition>;
-    snapshot(flowId: string): Promise<FlowVersion>;
-    restore(flowId: string, version: number): Promise<void>;
-}
-export {};