@mingchuno/agent-workflows 0.1.0

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

@@ -0,0 +1,486 @@
+import type { RunRecord } from "../domain.js";
+import type { InvocationRecord } from "../store.js";
+export declare const application: import("drizzle-orm/pg-core").PgSchema<"agent_workflows">;
+export declare const projects: import("drizzle-orm/pg-core").PgTableWithColumns<{
+    name: "projects";
+    schema: "agent_workflows";
+    columns: {
+        scope: import("drizzle-orm/pg-core").PgColumn<{
+            name: "scope";
+            tableName: "projects";
+            dataType: "string";
+            columnType: "PgText";
+            data: string;
+            driverParam: string;
+            notNull: true;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: [string, ...string[]];
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        id: import("drizzle-orm/pg-core").PgColumn<{
+            name: "id";
+            tableName: "projects";
+            dataType: "string";
+            columnType: "PgText";
+            data: string;
+            driverParam: string;
+            notNull: true;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: [string, ...string[]];
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        paused: import("drizzle-orm/pg-core").PgColumn<{
+            name: "paused";
+            tableName: "projects";
+            dataType: "boolean";
+            columnType: "PgBoolean";
+            data: boolean;
+            driverParam: boolean;
+            notNull: true;
+            hasDefault: true;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: undefined;
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        blocked: import("drizzle-orm/pg-core").PgColumn<{
+            name: "blocked";
+            tableName: "projects";
+            dataType: "string";
+            columnType: "PgText";
+            data: string;
+            driverParam: string;
+            notNull: false;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: [string, ...string[]];
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+    };
+    dialect: 'pg';
+}>;
+export declare const runs: import("drizzle-orm/pg-core").PgTableWithColumns<{
+    name: "runs";
+    schema: "agent_workflows";
+    columns: {
+        scope: import("drizzle-orm/pg-core").PgColumn<{
+            name: "scope";
+            tableName: "runs";
+            dataType: "string";
+            columnType: "PgText";
+            data: string;
+            driverParam: string;
+            notNull: true;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: [string, ...string[]];
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        id: import("drizzle-orm/pg-core").PgColumn<{
+            name: "id";
+            tableName: "runs";
+            dataType: "string";
+            columnType: "PgText";
+            data: string;
+            driverParam: string;
+            notNull: true;
+            hasDefault: false;
+            isPrimaryKey: true;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: [string, ...string[]];
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        taskKey: import("drizzle-orm/pg-core").PgColumn<{
+            name: "task_key";
+            tableName: "runs";
+            dataType: "string";
+            columnType: "PgText";
+            data: string;
+            driverParam: string;
+            notNull: true;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: [string, ...string[]];
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        attempt: import("drizzle-orm/pg-core").PgColumn<{
+            name: "attempt";
+            tableName: "runs";
+            dataType: "number";
+            columnType: "PgInteger";
+            data: number;
+            driverParam: string | number;
+            notNull: true;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: undefined;
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        record: import("drizzle-orm/pg-core").PgColumn<{
+            name: "record";
+            tableName: "runs";
+            dataType: "json";
+            columnType: "PgJsonb";
+            data: RunRecord;
+            driverParam: unknown;
+            notNull: true;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: undefined;
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {
+            $type: RunRecord;
+        }>;
+    };
+    dialect: 'pg';
+}>;
+export declare const events: import("drizzle-orm/pg-core").PgTableWithColumns<{
+    name: "events";
+    schema: "agent_workflows";
+    columns: {
+        sequence: import("drizzle-orm/pg-core").PgColumn<{
+            name: "sequence";
+            tableName: "events";
+            dataType: "number";
+            columnType: "PgBigSerial53";
+            data: number;
+            driverParam: number;
+            notNull: true;
+            hasDefault: true;
+            isPrimaryKey: true;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: undefined;
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        scope: import("drizzle-orm/pg-core").PgColumn<{
+            name: "scope";
+            tableName: "events";
+            dataType: "string";
+            columnType: "PgText";
+            data: string;
+            driverParam: string;
+            notNull: true;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: [string, ...string[]];
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        runId: import("drizzle-orm/pg-core").PgColumn<{
+            name: "run_id";
+            tableName: "events";
+            dataType: "string";
+            columnType: "PgText";
+            data: string;
+            driverParam: string;
+            notNull: false;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: [string, ...string[]];
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        kind: import("drizzle-orm/pg-core").PgColumn<{
+            name: "kind";
+            tableName: "events";
+            dataType: "string";
+            columnType: "PgText";
+            data: string;
+            driverParam: string;
+            notNull: true;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: [string, ...string[]];
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        payload: import("drizzle-orm/pg-core").PgColumn<{
+            name: "payload";
+            tableName: "events";
+            dataType: "json";
+            columnType: "PgJsonb";
+            data: unknown;
+            driverParam: unknown;
+            notNull: true;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: undefined;
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {
+            $type: unknown;
+        }>;
+        createdAt: import("drizzle-orm/pg-core").PgColumn<{
+            name: "created_at";
+            tableName: "events";
+            dataType: "date";
+            columnType: "PgTimestamp";
+            data: Date;
+            driverParam: string;
+            notNull: true;
+            hasDefault: true;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: undefined;
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+    };
+    dialect: 'pg';
+}>;
+export declare const invocations: import("drizzle-orm/pg-core").PgTableWithColumns<{
+    name: "invocations";
+    schema: "agent_workflows";
+    columns: {
+        scope: import("drizzle-orm/pg-core").PgColumn<{
+            name: "scope";
+            tableName: "invocations";
+            dataType: "string";
+            columnType: "PgText";
+            data: string;
+            driverParam: string;
+            notNull: true;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: [string, ...string[]];
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        id: import("drizzle-orm/pg-core").PgColumn<{
+            name: "id";
+            tableName: "invocations";
+            dataType: "string";
+            columnType: "PgText";
+            data: string;
+            driverParam: string;
+            notNull: true;
+            hasDefault: false;
+            isPrimaryKey: true;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: [string, ...string[]];
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        runId: import("drizzle-orm/pg-core").PgColumn<{
+            name: "run_id";
+            tableName: "invocations";
+            dataType: "string";
+            columnType: "PgText";
+            data: string;
+            driverParam: string;
+            notNull: true;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: [string, ...string[]];
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        record: import("drizzle-orm/pg-core").PgColumn<{
+            name: "record";
+            tableName: "invocations";
+            dataType: "json";
+            columnType: "PgJsonb";
+            data: InvocationRecord;
+            driverParam: unknown;
+            notNull: true;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: undefined;
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {
+            $type: InvocationRecord;
+        }>;
+    };
+    dialect: 'pg';
+}>;
+export declare const commands: import("drizzle-orm/pg-core").PgTableWithColumns<{
+    name: "commands";
+    schema: "agent_workflows";
+    columns: {
+        id: import("drizzle-orm/pg-core").PgColumn<{
+            name: "id";
+            tableName: "commands";
+            dataType: "string";
+            columnType: "PgText";
+            data: string;
+            driverParam: string;
+            notNull: true;
+            hasDefault: false;
+            isPrimaryKey: true;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: [string, ...string[]];
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        scope: import("drizzle-orm/pg-core").PgColumn<{
+            name: "scope";
+            tableName: "commands";
+            dataType: "string";
+            columnType: "PgText";
+            data: string;
+            driverParam: string;
+            notNull: true;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: [string, ...string[]];
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        kind: import("drizzle-orm/pg-core").PgColumn<{
+            name: "kind";
+            tableName: "commands";
+            dataType: "string";
+            columnType: "PgText";
+            data: string;
+            driverParam: string;
+            notNull: true;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: [string, ...string[]];
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        target: import("drizzle-orm/pg-core").PgColumn<{
+            name: "target";
+            tableName: "commands";
+            dataType: "string";
+            columnType: "PgText";
+            data: string;
+            driverParam: string;
+            notNull: true;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: [string, ...string[]];
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        status: import("drizzle-orm/pg-core").PgColumn<{
+            name: "status";
+            tableName: "commands";
+            dataType: "string";
+            columnType: "PgText";
+            data: string;
+            driverParam: string;
+            notNull: true;
+            hasDefault: true;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: [string, ...string[]];
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        error: import("drizzle-orm/pg-core").PgColumn<{
+            name: "error";
+            tableName: "commands";
+            dataType: "string";
+            columnType: "PgText";
+            data: string;
+            driverParam: string;
+            notNull: false;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: [string, ...string[]];
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        createdAt: import("drizzle-orm/pg-core").PgColumn<{
+            name: "created_at";
+            tableName: "commands";
+            dataType: "date";
+            columnType: "PgTimestamp";
+            data: Date;
+            driverParam: string;
+            notNull: true;
+            hasDefault: true;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: undefined;
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+    };
+    dialect: 'pg';
+}>;

package/dist/src/db/schema.js

@@ -0,0 +1,46 @@
+import { bigserial, boolean, integer, jsonb, pgSchema, primaryKey, text, timestamp, unique, } from "drizzle-orm/pg-core";
+export const application = pgSchema("agent_workflows");
+export const projects = application.table("projects", {
+    scope: text().notNull(),
+    id: text().notNull(),
+    paused: boolean().notNull().default(false),
+    blocked: text(),
+}, (table) => [
+    primaryKey({ name: "projects_pkey", columns: [table.scope, table.id] }),
+]);
+export const runs = application.table("runs", {
+    scope: text().notNull(),
+    id: text().primaryKey(),
+    taskKey: text("task_key").notNull(),
+    attempt: integer().notNull(),
+    record: jsonb().$type().notNull(),
+}, (table) => [
+    unique("runs_scope_task_key_attempt_key").on(table.scope, table.taskKey, table.attempt),
+]);
+export const events = application.table("events", {
+    sequence: bigserial({ mode: "number" }).primaryKey(),
+    scope: text().notNull(),
+    runId: text("run_id"),
+    kind: text().notNull(),
+    payload: jsonb().$type().notNull(),
+    createdAt: timestamp("created_at", { withTimezone: true })
+        .notNull()
+        .defaultNow(),
+});
+export const invocations = application.table("invocations", {
+    scope: text().notNull(),
+    id: text().primaryKey(),
+    runId: text("run_id").notNull(),
+    record: jsonb().$type().notNull(),
+});
+export const commands = application.table("commands", {
+    id: text().primaryKey(),
+    scope: text().notNull(),
+    kind: text().notNull(),
+    target: text().notNull(),
+    status: text().notNull().default("pending"),
+    error: text(),
+    createdAt: timestamp("created_at", { withTimezone: true })
+        .notNull()
+        .defaultNow(),
+});

package/dist/src/domain.d.ts

@@ -0,0 +1,133 @@
+import { z } from "zod";
+import type { AgentProfile, Project } from "./config.js";
+export interface Issue {
+    id: string;
+    number: number;
+    title: string;
+    body: string;
+    url: string;
+    labels: string[];
+    open: boolean;
+}
+export interface ChangeRequest {
+    id: number;
+    url: string;
+    head: string;
+}
+export declare const publicationSchema: z.ZodObject<{
+    commitMessage: z.ZodString;
+    title: z.ZodString;
+    description: z.ZodString;
+}, z.core.$strict>;
+export type Publication = z.infer<typeof publicationSchema>;
+export declare const reviewSchema: z.ZodObject<{
+    summary: z.ZodString;
+    findings: z.ZodArray<z.ZodObject<{
+        body: z.ZodString;
+        path: z.ZodOptional<z.ZodString>;
+        line: z.ZodOptional<z.ZodNumber>;
+    }, z.core.$strict>>;
+}, z.core.$strict>;
+export type Review = z.infer<typeof reviewSchema>;
+export interface ValidationResult {
+    command: string;
+    args: string[];
+    exitCode: number;
+    log: string;
+    startedAt: string;
+    finishedAt: string;
+}
+export interface Snapshot {
+    branch: string;
+    head: string;
+    fingerprint: string;
+    diff: string;
+    paths: string[];
+    files: Record<string, string | null>;
+}
+export interface Workspace {
+    check(project: Project): Promise<void>;
+    prepare(project: Project, branch: string, signal?: AbortSignal): Promise<Snapshot>;
+    inspect(project: Project): Promise<Snapshot>;
+    verify(project: Project, expected: Snapshot): Promise<void>;
+    commit(project: Project, expected: Snapshot, publication: Publication, runId: string, signal?: AbortSignal): Promise<string>;
+    push(project: Project, branch: string, head: string, signal?: AbortSignal): Promise<void>;
+    release(project: Project): Promise<void>;
+}
+export interface HostingAdapter {
+    identity: string;
+    preflight?(): Promise<void>;
+    listIssues(labels: string[]): Promise<Issue[]>;
+    getIssue(number: number): Promise<Issue>;
+    findChange(branch: string): Promise<ChangeRequest | undefined>;
+    createChange(input: {
+        branch: string;
+        base: string;
+        head: string;
+        issue: Issue;
+        publication: Publication;
+        runId: string;
+    }): Promise<ChangeRequest>;
+    head(change: ChangeRequest): Promise<string>;
+    publishReview(input: {
+        change: ChangeRequest;
+        head: string;
+        review: Review;
+        runId: string;
+        diff: string;
+    }): Promise<void>;
+}
+export interface AgentInvocation {
+    id: string;
+    runId: string;
+    step: string;
+    cwd: string;
+    prompt: string;
+    profile: AgentProfile;
+    skills: string[];
+    processFile?: string;
+    readOnly: boolean;
+    signal: AbortSignal;
+    timeoutMs?: number;
+    session: (id: string) => Promise<void>;
+    event: (event: unknown) => Promise<void>;
+}
+export interface EffectiveProfile {
+    provider: string;
+    model: string;
+    reasoningEffort: string;
+    context: AgentProfile["context"] | "unknown";
+    contextWindowTokens: number | "unknown";
+}
+export interface AgentAdapter {
+    validate(profile: AgentProfile, signal?: AbortSignal): Promise<EffectiveProfile>;
+    invoke(invocation: AgentInvocation): Promise<string>;
+}
+export type Outcome = "queued" | "running" | "completed" | "failed" | "blocked" | "cancelled" | "no-change" | "ineligible";
+export interface RunRecord {
+    id: string;
+    projectId: string;
+    checkout: string;
+    taskKey: string;
+    attempt: number;
+    retryOf?: string;
+    issue: Issue;
+    outcome: Outcome;
+    phase: string;
+    createdAt: string;
+    updatedAt: string;
+    branch: string;
+    base?: string;
+    head?: string;
+    snapshot?: Snapshot;
+    validation?: ValidationResult[];
+    publication?: Publication;
+    change?: ChangeRequest;
+    review?: Review;
+    reviewHead?: string;
+    error?: string;
+}
+export declare class BlockedError extends Error {
+    constructor(message: string);
+}
+export declare function isBlockedError(error: unknown): error is BlockedError;

package/dist/src/domain.js

@@ -0,0 +1,24 @@
+import { z } from "zod";
+export const publicationSchema = z.strictObject({
+    commitMessage: z.string().trim().min(1).max(10000),
+    title: z.string().trim().min(1).max(240),
+    description: z.string().trim().min(1).max(60000),
+});
+export const reviewSchema = z.strictObject({
+    summary: z.string().min(1),
+    findings: z.array(z.strictObject({
+        body: z.string().min(1),
+        path: z.string().optional(),
+        line: z.number().int().positive().optional(),
+    })),
+});
+export class BlockedError extends Error {
+    constructor(message) {
+        super(message);
+        this.name = "BlockedError";
+    }
+}
+export function isBlockedError(error) {
+    return (error instanceof BlockedError ||
+        (error instanceof Error && error.name === "BlockedError"));
+}

package/dist/src/index.d.ts

@@ -0,0 +1,8 @@
+export * from "./adapters/agents.js";
+export * from "./adapters/hosting.js";
+export * from "./config.js";
+export * from "./domain.js";
+export * from "./operations.js";
+export * from "./runner.js";
+export * from "./store.js";
+export * from "./workspace.js";