@fkqfkq123/opencode-autopilot 0.1.0

package/dist/packages/adapters/opencode/src/opencode-session-client.js

@@ -0,0 +1,382 @@
+import { randomUUID } from "node:crypto";
+export class InMemoryOpencodeSessionClient {
+    sessions = new Map();
+    eventQueue = new Map();
+    async createSession(input) {
+        const sessionId = randomUUID();
+        this.sessions.set(sessionId, {
+            sessionId,
+            title: input.title,
+            status: "idle",
+            prompts: [],
+        });
+        this.enqueue(sessionId, { type: "session.created", sessionId });
+        return { sessionId };
+    }
+    async ensureSessionReady(sessionId, title) {
+        if (!this.sessions.has(sessionId)) {
+            this.sessions.set(sessionId, {
+                sessionId,
+                title,
+                status: "idle",
+                prompts: [],
+            });
+        }
+    }
+    async injectPrompt(input) {
+        let session = this.sessions.get(input.sessionId);
+        if (!session) {
+            session = {
+                sessionId: input.sessionId,
+                title: "recovered",
+                status: "idle",
+                prompts: [],
+            };
+            this.sessions.set(input.sessionId, session);
+        }
+        session.status = "running";
+        this.enqueue(input.sessionId, { type: "session.status", sessionId: input.sessionId, payload: { type: "busy" } });
+        session.prompts.push(input.prompt);
+        session.status = "idle";
+        this.enqueue(input.sessionId, { type: "session.idle", sessionId: input.sessionId });
+        return {
+            dispatchMode: "in_memory_inline",
+            statusBefore: "idle",
+        };
+    }
+    async abort(sessionId) {
+        const session = this.sessions.get(sessionId);
+        if (!session) {
+            return;
+        }
+        session.status = "failed";
+        this.enqueue(sessionId, { type: "session.error", sessionId, payload: { message: "aborted" } });
+    }
+    async getSessionStatus(sessionId) {
+        const session = this.sessions.get(sessionId);
+        return session?.status ?? "missing";
+    }
+    async *streamEvents(_sessionId) {
+        while (true) {
+            const queue = this.eventQueue.get(_sessionId) ?? [];
+            if (queue.length > 0) {
+                const next = queue.shift();
+                this.eventQueue.set(_sessionId, queue);
+                if (next) {
+                    yield next;
+                    continue;
+                }
+            }
+            await new Promise((resolve) => setTimeout(resolve, 10));
+        }
+    }
+    enqueue(sessionId, event) {
+        const queue = this.eventQueue.get(sessionId) ?? [];
+        queue.push(event);
+        this.eventQueue.set(sessionId, queue);
+    }
+}
+export class SdkOpencodeSessionClient {
+    client;
+    eventQueue = new Map();
+    knownSessions = new Set();
+    eventPumpStarted = false;
+    constructor(client) {
+        this.client = client;
+    }
+    unwrapFields(value) {
+        if (!value || typeof value !== "object") {
+            return null;
+        }
+        if ("data" in value && value.data && typeof value.data === "object") {
+            return value.data;
+        }
+        return value;
+    }
+    async createSession(input) {
+        this.ensureEventPump();
+        const session = this.unwrapFields(await this.client.session.create({
+            body: { title: input.title },
+        }));
+        if (!session?.id) {
+            throw new Error("OpenCode SDK createSession response did not include id");
+        }
+        this.knownSessions.add(session.id);
+        this.enqueue(session.id, { type: "session.created", sessionId: session.id });
+        return { sessionId: session.id };
+    }
+    async ensureSessionReady(sessionId, _title) {
+        this.ensureEventPump();
+        this.knownSessions.add(sessionId);
+    }
+    async injectPrompt(input) {
+        this.ensureEventPump();
+        this.knownSessions.add(input.sessionId);
+        const request = {
+            path: { id: input.sessionId },
+            body: {
+                parts: [
+                    {
+                        type: "text",
+                        text: input.prompt,
+                    },
+                ],
+                ...(input.agent ? { agent: input.agent } : {}),
+                ...(input.model
+                    ? {
+                        model: {
+                            providerID: input.model.providerID,
+                            modelID: input.model.modelID,
+                            ...(input.model.variant ? { variant: input.model.variant } : {}),
+                        },
+                    }
+                    : {}),
+            },
+        };
+        const currentStatus = await this.getSessionStatus(input.sessionId);
+        if (currentStatus === "running" && this.client.session.promptAsync) {
+            await this.client.session.promptAsync(request);
+            return {
+                dispatchMode: "sdk_prompt_async",
+                statusBefore: currentStatus,
+            };
+        }
+        void this.client.session.prompt(request).catch((error) => {
+            this.enqueue(input.sessionId, {
+                type: "session.error",
+                sessionId: input.sessionId,
+                payload: {
+                    message: error instanceof Error ? error.message : String(error),
+                },
+            });
+        });
+        return {
+            dispatchMode: "sdk_prompt_background",
+            statusBefore: currentStatus,
+        };
+    }
+    async abort(sessionId) {
+        await this.client.session.abort({ path: { id: sessionId } });
+    }
+    async getSessionStatus(sessionId) {
+        if (!this.client.session.status) {
+            return this.knownSessions.has(sessionId) ? "idle" : "missing";
+        }
+        try {
+            const status = this.unwrapFields(await this.client.session.status({ path: { id: sessionId } }));
+            if (status?.type === "busy" || status?.type === "retry" || status?.type === "running") {
+                return "running";
+            }
+            return this.knownSessions.has(sessionId) ? "idle" : "missing";
+        }
+        catch (error) {
+            const message = error instanceof Error ? error.message : String(error);
+            if (message.includes("404") || message.includes("not found")) {
+                return "missing";
+            }
+            throw error;
+        }
+    }
+    async *streamEvents(sessionId) {
+        this.ensureEventPump();
+        while (true) {
+            const queue = this.eventQueue.get(sessionId) ?? [];
+            if (queue.length > 0) {
+                const next = queue.shift();
+                this.eventQueue.set(sessionId, queue);
+                if (next) {
+                    yield next;
+                    continue;
+                }
+            }
+            await new Promise((resolve) => setTimeout(resolve, 10));
+        }
+    }
+    ensureEventPump() {
+        if (this.eventPumpStarted || !this.client.event?.subscribe) {
+            return;
+        }
+        this.eventPumpStarted = true;
+        void this.startEventPump();
+    }
+    async startEventPump() {
+        const subscription = await this.client.event?.subscribe?.();
+        if (!subscription) {
+            return;
+        }
+        for await (const event of subscription.stream) {
+            const sessionID = typeof event.properties?.sessionID === "string"
+                ? event.properties.sessionID
+                : undefined;
+            if (!sessionID || !this.knownSessions.has(sessionID)) {
+                continue;
+            }
+            if (event.type === "session.status" || event.type === "session.idle" || event.type === "session.error") {
+                this.enqueue(sessionID, {
+                    type: event.type,
+                    sessionId: sessionID,
+                    ...(event.properties ? { payload: event.properties } : {}),
+                });
+            }
+        }
+    }
+    enqueue(sessionId, event) {
+        const queue = this.eventQueue.get(sessionId) ?? [];
+        queue.push(event);
+        this.eventQueue.set(sessionId, queue);
+    }
+}
+export class HttpOpencodeSessionClient {
+    options;
+    constructor(options) {
+        this.options = options;
+    }
+    async ensureSessionReady(_sessionId, _title) { }
+    async createSession(input) {
+        const data = await this.request("POST", "/session", {
+            title: input.title,
+        });
+        if (!data.id) {
+            throw new Error("Opencode createSession response did not include id");
+        }
+        return { sessionId: data.id };
+    }
+    async injectPrompt(input) {
+        const body = {
+            parts: [
+                {
+                    type: "text",
+                    text: input.prompt,
+                },
+            ],
+        };
+        if (input.agent) {
+            body.agent = input.agent;
+        }
+        if (input.model) {
+            body.model = {
+                providerID: input.model.providerID,
+                modelID: input.model.modelID,
+            };
+            if (input.model.variant) {
+                body.variant = input.model.variant;
+            }
+        }
+        await this.requestVoid("POST", `/session/${encodeURIComponent(input.sessionId)}/prompt_async`, body);
+        return {
+            dispatchMode: "http_prompt_async",
+            statusBefore: "idle",
+        };
+    }
+    async abort(sessionId) {
+        await this.requestVoid("POST", `/session/${encodeURIComponent(sessionId)}/abort`);
+    }
+    async getSessionStatus(sessionId) {
+        const data = await this.request("GET", "/session/status");
+        const info = data[sessionId];
+        if (!info) {
+            return "missing";
+        }
+        if (info.type === "busy" || info.type === "retry") {
+            return "running";
+        }
+        return "idle";
+    }
+    async *streamEvents(_sessionId) {
+        const headers = {};
+        if (this.options.password) {
+            const token = Buffer.from(`:${this.options.password}`).toString("base64");
+            headers.Authorization = `Basic ${token}`;
+        }
+        const response = await fetch(new URL("/event", this.options.baseUrl), {
+            headers,
+        });
+        if (!response.ok || !response.body) {
+            throw new Error(`Opencode event stream failed: ${response.status} ${response.statusText}`);
+        }
+        const reader = response.body.getReader();
+        const decoder = new TextDecoder();
+        let buffer = "";
+        while (true) {
+            const result = await reader.read();
+            if (result.done) {
+                break;
+            }
+            buffer += decoder.decode(result.value, { stream: true });
+            const chunks = buffer.split("\n\n");
+            buffer = chunks.pop() ?? "";
+            for (const chunk of chunks) {
+                const dataLine = chunk
+                    .split("\n")
+                    .find((line) => line.startsWith("data:"));
+                if (!dataLine) {
+                    continue;
+                }
+                const raw = dataLine.slice(5).trim();
+                if (!raw) {
+                    continue;
+                }
+                let parsed;
+                try {
+                    parsed = JSON.parse(raw);
+                }
+                catch {
+                    continue;
+                }
+                if (!parsed || typeof parsed !== "object") {
+                    continue;
+                }
+                const event = parsed;
+                const sessionID = typeof event.properties?.sessionID === "string"
+                    ? event.properties.sessionID
+                    : undefined;
+                if (sessionID !== _sessionId || !event.type) {
+                    continue;
+                }
+                const nextEvent = {
+                    type: event.type,
+                    sessionId: sessionID,
+                };
+                if (event.properties) {
+                    nextEvent.payload = event.properties;
+                }
+                yield nextEvent;
+            }
+        }
+    }
+    async request(method, path, body) {
+        const headers = {
+            "Content-Type": "application/json",
+        };
+        if (this.options.password) {
+            const token = Buffer.from(`:${this.options.password}`).toString("base64");
+            headers.Authorization = `Basic ${token}`;
+        }
+        const response = await fetch(new URL(path, this.options.baseUrl), {
+            method,
+            headers,
+            body: body === undefined ? undefined : JSON.stringify(body),
+        });
+        if (!response.ok) {
+            throw new Error(`Opencode request failed: ${response.status} ${response.statusText}`);
+        }
+        return (await response.json());
+    }
+    async requestVoid(method, path, body) {
+        const headers = {
+            "Content-Type": "application/json",
+        };
+        if (this.options.password) {
+            const token = Buffer.from(`:${this.options.password}`).toString("base64");
+            headers.Authorization = `Basic ${token}`;
+        }
+        const response = await fetch(new URL(path, this.options.baseUrl), {
+            method,
+            headers,
+            body: body === undefined ? undefined : JSON.stringify(body),
+        });
+        if (!response.ok && response.status !== 204) {
+            throw new Error(`Opencode request failed: ${response.status} ${response.statusText}`);
+        }
+    }
+}

package/dist/packages/core/src/artifacts/artifact-evaluator.d.ts

@@ -0,0 +1,17 @@
+import type { Question } from "../human-actions/question";
+import type { Phase } from "../state/phase";
+import type { WorkflowState } from "../state/workflow-state";
+export interface ArtifactEvaluation {
+    valid: boolean;
+    readyForNextPhase: boolean;
+    missing: string[];
+    summary?: string;
+    questions?: Question[];
+    requiresApproval?: boolean;
+    reportStatus?: "pass" | "fail" | "unknown";
+    hasBlockingSeverity?: boolean;
+}
+export interface ArtifactEvaluator {
+    evaluate(state: WorkflowState): Promise<ArtifactEvaluation>;
+    prepareForPhase?(workflowId: string, phase: Phase, previousPhase: Phase): Promise<void>;
+}

package/dist/packages/core/src/artifacts/artifact-evaluator.js

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

package/dist/packages/core/src/artifacts/artifact.d.ts

@@ -0,0 +1,7 @@
+export interface ArtifactRef {
+    id: string;
+    type: string;
+    uri: string;
+    version: number;
+    updatedAt: string;
+}

package/dist/packages/core/src/artifacts/artifact.js

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

package/dist/packages/core/src/human-actions/human-action-record.d.ts

@@ -0,0 +1,10 @@
+import type { HumanAction } from "./human-action";
+export type HumanActionStatus = "pending" | "presented" | "responded" | "consumed";
+export interface HumanActionRecord {
+    id: string;
+    workflowId: string;
+    action: HumanAction;
+    status: HumanActionStatus;
+    createdAt: string;
+    respondedAt?: string;
+}

package/dist/packages/core/src/human-actions/human-action-record.js

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

package/dist/packages/core/src/human-actions/human-action.d.ts

@@ -0,0 +1,13 @@
+import type { Phase } from "../state/phase";
+import type { Question } from "./question";
+export type HumanActionType = "need_answers" | "need_approval" | "blocked" | "done";
+export interface HumanAction {
+    type: HumanActionType;
+    workflowId: string;
+    phase: Phase;
+    reason: string;
+    required: boolean;
+    questions?: Question[];
+    summary?: string;
+    createdAt: string;
+}

package/dist/packages/core/src/human-actions/human-action.js

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

package/dist/packages/core/src/human-actions/question.d.ts

@@ -0,0 +1,8 @@
+export type QuestionPriority = "required" | "recommended" | "optional";
+export interface Question {
+    id: string;
+    priority: QuestionPriority;
+    text: string;
+    canAutoResolve: boolean;
+    suggestedAnswer?: string;
+}

package/dist/packages/core/src/human-actions/question.js

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

package/dist/packages/core/src/state/phase.d.ts

@@ -0,0 +1,2 @@
+export type Phase = "spec_refinement" | "plan" | "develop" | "review" | "test" | "done" | "blocked";
+export type WorkflowStatus = "pending" | "in_progress" | "waiting_human" | "completed" | "blocked";

package/dist/packages/core/src/state/phase.js

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

package/dist/packages/core/src/state/workflow-runtime-state.d.ts

@@ -0,0 +1,14 @@
+export type RecoveryState = "idle" | "recovering";
+export interface WorkflowRuntimeState {
+    workflowId: string;
+    preferredForegroundSessionId?: string | null;
+    leaseOwner?: string;
+    leaseExpiresAt?: string;
+    recoveryState: RecoveryState;
+    waitingHumanActionId?: string | null;
+    consecutiveFailures: number;
+    refinementAttempts?: number;
+    refinementLastDispatchSummary?: string | null;
+    refinementEscalationReason?: string | null;
+    lastContinuationAt?: string;
+}

package/dist/packages/core/src/state/workflow-runtime-state.js

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

package/dist/packages/core/src/state/workflow-state.d.ts

@@ -0,0 +1,13 @@
+import type { Phase, WorkflowStatus } from "./phase";
+export interface WorkflowState {
+    workflowId: string;
+    phase: Phase;
+    status: WorkflowStatus;
+    approved: boolean;
+    iteration: number;
+    maxIterations: number;
+    blockReason: string | null;
+    activeSessionId: string | null;
+    phaseEnteredAt: string;
+    updatedAt: string;
+}

package/dist/packages/core/src/state/workflow-state.js

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

package/dist/packages/core/src/transitions/default-phase-transition.d.ts

@@ -0,0 +1,5 @@
+import type { PhaseTransition, PhaseTransitionInput } from "./phase-transition";
+import type { TransitionAction } from "./transition-action";
+export declare class DefaultPhaseTransition implements PhaseTransition {
+    decide(input: PhaseTransitionInput): Promise<TransitionAction>;
+}