@mingchuno/agent-workflows 0.1.0

package/dist/src/config.d.ts

@@ -0,0 +1,224 @@
+import { z } from "zod";
+export declare const profileSchema: z.ZodObject<{
+    provider: z.ZodEnum<{
+        codex: "codex";
+        copilot: "copilot";
+    }>;
+    model: z.ZodOptional<z.ZodString>;
+    reasoningEffort: z.ZodOptional<z.ZodString>;
+    context: z.ZodOptional<z.ZodObject<{
+        backgroundCompactionThreshold: z.ZodOptional<z.ZodNumber>;
+        bufferExhaustionThreshold: z.ZodOptional<z.ZodNumber>;
+    }, z.core.$strict>>;
+}, z.core.$strict>;
+export type AgentProfile = z.infer<typeof profileSchema>;
+export declare const stageSchema: z.ZodObject<{
+    profile: z.ZodOptional<z.ZodObject<{
+        provider: z.ZodOptional<z.ZodEnum<{
+            codex: "codex";
+            copilot: "copilot";
+        }>>;
+        model: z.ZodOptional<z.ZodOptional<z.ZodString>>;
+        reasoningEffort: z.ZodOptional<z.ZodOptional<z.ZodString>>;
+        context: z.ZodOptional<z.ZodOptional<z.ZodObject<{
+            backgroundCompactionThreshold: z.ZodOptional<z.ZodNumber>;
+            bufferExhaustionThreshold: z.ZodOptional<z.ZodNumber>;
+        }, z.core.$strict>>>;
+    }, z.core.$strict>>;
+    prompt: z.ZodDefault<z.ZodString>;
+    skills: z.ZodDefault<z.ZodArray<z.ZodString>>;
+    timeoutMs: z.ZodDefault<z.ZodNumber>;
+}, z.core.$strict>;
+export declare const projectSchema: z.ZodObject<{
+    id: z.ZodString;
+    checkout: z.ZodString;
+    hosting: z.ZodObject<{
+        provider: z.ZodEnum<{
+            github: "github";
+            gitlab: "gitlab";
+        }>;
+        origin: z.ZodURL;
+        repository: z.ZodString;
+        tokenEnv: z.ZodString;
+    }, z.core.$strict>;
+    labels: z.ZodDefault<z.ZodArray<z.ZodString>>;
+    baseBranch: z.ZodDefault<z.ZodString>;
+    remote: z.ZodDefault<z.ZodString>;
+    branchTemplate: z.ZodDefault<z.ZodString>;
+    pollIntervalMs: z.ZodDefault<z.ZodNumber>;
+    validation: z.ZodDefault<z.ZodArray<z.ZodObject<{
+        command: z.ZodString;
+        args: z.ZodDefault<z.ZodArray<z.ZodString>>;
+        timeoutMs: z.ZodDefault<z.ZodNumber>;
+    }, z.core.$strict>>>;
+    gitIdentity: z.ZodObject<{
+        name: z.ZodString;
+        email: z.ZodEmail;
+    }, z.core.$strict>;
+    agent: z.ZodObject<{
+        provider: z.ZodEnum<{
+            codex: "codex";
+            copilot: "copilot";
+        }>;
+        model: z.ZodOptional<z.ZodString>;
+        reasoningEffort: z.ZodOptional<z.ZodString>;
+        context: z.ZodOptional<z.ZodObject<{
+            backgroundCompactionThreshold: z.ZodOptional<z.ZodNumber>;
+            bufferExhaustionThreshold: z.ZodOptional<z.ZodNumber>;
+        }, z.core.$strict>>;
+    }, z.core.$strict>;
+    stages: z.ZodDefault<z.ZodObject<{
+        implementation: z.ZodDefault<z.ZodObject<{
+            profile: z.ZodOptional<z.ZodObject<{
+                provider: z.ZodOptional<z.ZodEnum<{
+                    codex: "codex";
+                    copilot: "copilot";
+                }>>;
+                model: z.ZodOptional<z.ZodOptional<z.ZodString>>;
+                reasoningEffort: z.ZodOptional<z.ZodOptional<z.ZodString>>;
+                context: z.ZodOptional<z.ZodOptional<z.ZodObject<{
+                    backgroundCompactionThreshold: z.ZodOptional<z.ZodNumber>;
+                    bufferExhaustionThreshold: z.ZodOptional<z.ZodNumber>;
+                }, z.core.$strict>>>;
+            }, z.core.$strict>>;
+            prompt: z.ZodDefault<z.ZodString>;
+            skills: z.ZodDefault<z.ZodArray<z.ZodString>>;
+            timeoutMs: z.ZodDefault<z.ZodNumber>;
+        }, z.core.$strict>>;
+        writing: z.ZodDefault<z.ZodObject<{
+            profile: z.ZodOptional<z.ZodObject<{
+                provider: z.ZodOptional<z.ZodEnum<{
+                    codex: "codex";
+                    copilot: "copilot";
+                }>>;
+                model: z.ZodOptional<z.ZodOptional<z.ZodString>>;
+                reasoningEffort: z.ZodOptional<z.ZodOptional<z.ZodString>>;
+                context: z.ZodOptional<z.ZodOptional<z.ZodObject<{
+                    backgroundCompactionThreshold: z.ZodOptional<z.ZodNumber>;
+                    bufferExhaustionThreshold: z.ZodOptional<z.ZodNumber>;
+                }, z.core.$strict>>>;
+            }, z.core.$strict>>;
+            prompt: z.ZodDefault<z.ZodString>;
+            skills: z.ZodDefault<z.ZodArray<z.ZodString>>;
+            timeoutMs: z.ZodDefault<z.ZodNumber>;
+        }, z.core.$strict>>;
+        review: z.ZodDefault<z.ZodObject<{
+            profile: z.ZodOptional<z.ZodObject<{
+                provider: z.ZodOptional<z.ZodEnum<{
+                    codex: "codex";
+                    copilot: "copilot";
+                }>>;
+                model: z.ZodOptional<z.ZodOptional<z.ZodString>>;
+                reasoningEffort: z.ZodOptional<z.ZodOptional<z.ZodString>>;
+                context: z.ZodOptional<z.ZodOptional<z.ZodObject<{
+                    backgroundCompactionThreshold: z.ZodOptional<z.ZodNumber>;
+                    bufferExhaustionThreshold: z.ZodOptional<z.ZodNumber>;
+                }, z.core.$strict>>>;
+            }, z.core.$strict>>;
+            prompt: z.ZodDefault<z.ZodString>;
+            skills: z.ZodDefault<z.ZodArray<z.ZodString>>;
+            timeoutMs: z.ZodDefault<z.ZodNumber>;
+        }, z.core.$strict>>;
+    }, z.core.$strict>>;
+}, z.core.$strict>;
+export declare const configSchema: z.ZodObject<{
+    id: z.ZodString;
+    databaseUrlEnv: z.ZodDefault<z.ZodString>;
+    stateDirectory: z.ZodDefault<z.ZodString>;
+    projects: z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        checkout: z.ZodString;
+        hosting: z.ZodObject<{
+            provider: z.ZodEnum<{
+                github: "github";
+                gitlab: "gitlab";
+            }>;
+            origin: z.ZodURL;
+            repository: z.ZodString;
+            tokenEnv: z.ZodString;
+        }, z.core.$strict>;
+        labels: z.ZodDefault<z.ZodArray<z.ZodString>>;
+        baseBranch: z.ZodDefault<z.ZodString>;
+        remote: z.ZodDefault<z.ZodString>;
+        branchTemplate: z.ZodDefault<z.ZodString>;
+        pollIntervalMs: z.ZodDefault<z.ZodNumber>;
+        validation: z.ZodDefault<z.ZodArray<z.ZodObject<{
+            command: z.ZodString;
+            args: z.ZodDefault<z.ZodArray<z.ZodString>>;
+            timeoutMs: z.ZodDefault<z.ZodNumber>;
+        }, z.core.$strict>>>;
+        gitIdentity: z.ZodObject<{
+            name: z.ZodString;
+            email: z.ZodEmail;
+        }, z.core.$strict>;
+        agent: z.ZodObject<{
+            provider: z.ZodEnum<{
+                codex: "codex";
+                copilot: "copilot";
+            }>;
+            model: z.ZodOptional<z.ZodString>;
+            reasoningEffort: z.ZodOptional<z.ZodString>;
+            context: z.ZodOptional<z.ZodObject<{
+                backgroundCompactionThreshold: z.ZodOptional<z.ZodNumber>;
+                bufferExhaustionThreshold: z.ZodOptional<z.ZodNumber>;
+            }, z.core.$strict>>;
+        }, z.core.$strict>;
+        stages: z.ZodDefault<z.ZodObject<{
+            implementation: z.ZodDefault<z.ZodObject<{
+                profile: z.ZodOptional<z.ZodObject<{
+                    provider: z.ZodOptional<z.ZodEnum<{
+                        codex: "codex";
+                        copilot: "copilot";
+                    }>>;
+                    model: z.ZodOptional<z.ZodOptional<z.ZodString>>;
+                    reasoningEffort: z.ZodOptional<z.ZodOptional<z.ZodString>>;
+                    context: z.ZodOptional<z.ZodOptional<z.ZodObject<{
+                        backgroundCompactionThreshold: z.ZodOptional<z.ZodNumber>;
+                        bufferExhaustionThreshold: z.ZodOptional<z.ZodNumber>;
+                    }, z.core.$strict>>>;
+                }, z.core.$strict>>;
+                prompt: z.ZodDefault<z.ZodString>;
+                skills: z.ZodDefault<z.ZodArray<z.ZodString>>;
+                timeoutMs: z.ZodDefault<z.ZodNumber>;
+            }, z.core.$strict>>;
+            writing: z.ZodDefault<z.ZodObject<{
+                profile: z.ZodOptional<z.ZodObject<{
+                    provider: z.ZodOptional<z.ZodEnum<{
+                        codex: "codex";
+                        copilot: "copilot";
+                    }>>;
+                    model: z.ZodOptional<z.ZodOptional<z.ZodString>>;
+                    reasoningEffort: z.ZodOptional<z.ZodOptional<z.ZodString>>;
+                    context: z.ZodOptional<z.ZodOptional<z.ZodObject<{
+                        backgroundCompactionThreshold: z.ZodOptional<z.ZodNumber>;
+                        bufferExhaustionThreshold: z.ZodOptional<z.ZodNumber>;
+                    }, z.core.$strict>>>;
+                }, z.core.$strict>>;
+                prompt: z.ZodDefault<z.ZodString>;
+                skills: z.ZodDefault<z.ZodArray<z.ZodString>>;
+                timeoutMs: z.ZodDefault<z.ZodNumber>;
+            }, z.core.$strict>>;
+            review: z.ZodDefault<z.ZodObject<{
+                profile: z.ZodOptional<z.ZodObject<{
+                    provider: z.ZodOptional<z.ZodEnum<{
+                        codex: "codex";
+                        copilot: "copilot";
+                    }>>;
+                    model: z.ZodOptional<z.ZodOptional<z.ZodString>>;
+                    reasoningEffort: z.ZodOptional<z.ZodOptional<z.ZodString>>;
+                    context: z.ZodOptional<z.ZodOptional<z.ZodObject<{
+                        backgroundCompactionThreshold: z.ZodOptional<z.ZodNumber>;
+                        bufferExhaustionThreshold: z.ZodOptional<z.ZodNumber>;
+                    }, z.core.$strict>>>;
+                }, z.core.$strict>>;
+                prompt: z.ZodDefault<z.ZodString>;
+                skills: z.ZodDefault<z.ZodArray<z.ZodString>>;
+                timeoutMs: z.ZodDefault<z.ZodNumber>;
+            }, z.core.$strict>>;
+        }, z.core.$strict>>;
+    }, z.core.$strict>>;
+}, z.core.$strict>;
+export type Project = z.infer<typeof projectSchema>;
+export type Configuration = z.infer<typeof configSchema>;
+export type Stage = z.infer<typeof stageSchema>;
+export declare function resolveProfile(defaults: AgentProfile, override?: Partial<AgentProfile>): AgentProfile;

package/dist/src/config.js

@@ -0,0 +1,82 @@
+import { z } from "zod";
+export const profileSchema = z.strictObject({
+    provider: z.enum(["codex", "copilot"]),
+    model: z.string().min(1).optional(),
+    reasoningEffort: z.string().min(1).optional(),
+    context: z
+        .strictObject({
+        backgroundCompactionThreshold: z.number().positive().lt(1).optional(),
+        bufferExhaustionThreshold: z.number().positive().lte(1).optional(),
+    })
+        .optional(),
+});
+export const stageSchema = z.strictObject({
+    profile: profileSchema.partial().optional(),
+    prompt: z.string().default(""),
+    skills: z.array(z.string()).default([]),
+    timeoutMs: z.number().int().positive().default(1_800_000),
+});
+export const projectSchema = z.strictObject({
+    id: z.string().regex(/^[a-zA-Z0-9_-]+$/),
+    checkout: z.string().min(1),
+    hosting: z.strictObject({
+        provider: z.enum(["github", "gitlab"]),
+        origin: z.url(),
+        repository: z.string().min(1),
+        tokenEnv: z.string().regex(/^[A-Z_][A-Z0-9_]*$/),
+    }),
+    labels: z.array(z.string().min(1)).min(1).default(["ready-for-agent"]),
+    baseBranch: z.string().min(1).default("main"),
+    remote: z
+        .string()
+        .regex(/^[a-zA-Z0-9_-]+$/)
+        .default("origin"),
+    branchTemplate: z
+        .string()
+        .includes("{issue}")
+        .default("agent/{issue}-{attempt}"),
+    pollIntervalMs: z.number().int().min(100).default(30_000),
+    validation: z
+        .array(z.strictObject({
+        command: z.string().min(1),
+        args: z.array(z.string()).default([]),
+        timeoutMs: z.number().int().positive().default(300_000),
+    }))
+        .default([]),
+    gitIdentity: z.strictObject({ name: z.string().min(1), email: z.email() }),
+    agent: profileSchema,
+    stages: z
+        .strictObject({
+        implementation: stageSchema.default(() => ({
+            prompt: "",
+            skills: [],
+            timeoutMs: 1_800_000,
+        })),
+        writing: stageSchema.default(() => ({
+            prompt: "",
+            skills: [],
+            timeoutMs: 1_800_000,
+        })),
+        review: stageSchema.default(() => ({
+            prompt: "",
+            skills: [],
+            timeoutMs: 1_800_000,
+        })),
+    })
+        .default(() => ({
+        implementation: { prompt: "", skills: [], timeoutMs: 1_800_000 },
+        writing: { prompt: "", skills: [], timeoutMs: 1_800_000 },
+        review: { prompt: "", skills: [], timeoutMs: 1_800_000 },
+    })),
+});
+export const configSchema = z.strictObject({
+    id: z.string().regex(/^[a-zA-Z0-9_-]+$/),
+    databaseUrlEnv: z.string().default("AGENT_WORKFLOWS_DATABASE_URL"),
+    stateDirectory: z.string().default(".agent-workflows"),
+    projects: z.array(projectSchema).min(1),
+});
+export function resolveProfile(defaults, override = {}) {
+    if (override.provider && override.provider !== defaults.provider)
+        return profileSchema.parse(override);
+    return profileSchema.parse({ ...defaults, ...override });
+}

package/dist/src/db/locks.d.ts

@@ -0,0 +1,4 @@
+import type { PoolClient } from "pg";
+export declare function tryLock(client: PoolClient, key: string): Promise<boolean>;
+export declare function lockMigrations(client: PoolClient): Promise<void>;
+export declare function unlockAll(client: PoolClient): Promise<void>;

package/dist/src/db/locks.js

@@ -0,0 +1,14 @@
+// PostgreSQL session locks have no Drizzle query-builder equivalent.
+// Keep these fixed, parameterized driver calls on the owning connection.
+export async function tryLock(client, key) {
+    const result = await client.query("SELECT pg_try_advisory_lock(hashtextextended($1,0)) AS locked", [key]);
+    return result.rows[0]?.locked === true;
+}
+export async function lockMigrations(client) {
+    await client.query("SELECT pg_advisory_lock(hashtextextended($1,0))", [
+        "agent_workflows:migrations",
+    ]);
+}
+export async function unlockAll(client) {
+    await client.query("SELECT pg_advisory_unlock_all()");
+}

package/dist/src/db/migrate.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/src/db/migrate.js

@@ -0,0 +1,12 @@
+import { Pool } from "pg";
+import { migrateDatabase } from "./migrations.js";
+const databaseUrl = process.env.AGENT_WORKFLOWS_DATABASE_URL;
+if (!databaseUrl)
+    throw new Error("Set AGENT_WORKFLOWS_DATABASE_URL to a PostgreSQL URL");
+const pool = new Pool({ connectionString: databaseUrl });
+try {
+    await migrateDatabase(pool);
+}
+finally {
+    await pool.end();
+}

package/dist/src/db/migrations.d.ts

@@ -0,0 +1,2 @@
+import type { Pool } from "pg";
+export declare function migrateDatabase(pool: Pool): Promise<void>;

package/dist/src/db/migrations.js

@@ -0,0 +1,22 @@
+import { fileURLToPath } from "node:url";
+import { drizzle } from "drizzle-orm/node-postgres";
+import { migrate } from "drizzle-orm/node-postgres/migrator";
+import { lockMigrations, unlockAll } from "./locks.js";
+export async function migrateDatabase(pool) {
+    const client = await pool.connect();
+    try {
+        await lockMigrations(client);
+        await migrate(drizzle(client), {
+            migrationsFolder: fileURLToPath(new URL("../../drizzle", import.meta.url)),
+            migrationsSchema: "agent_workflows_migrations",
+        });
+    }
+    finally {
+        try {
+            await unlockAll(client);
+        }
+        finally {
+            client.release(true);
+        }
+    }
+}