@opencode_weave/weave 0.6.4 → 0.7.0

package/dist/features/workflow/schema.d.ts

@@ -0,0 +1,118 @@
+import { z } from "zod";
+/**
+ * Zod schema for step completion configuration in workflow definitions.
+ */
+export declare const CompletionConfigSchema: z.ZodObject<{
+    method: z.ZodEnum<{
+        user_confirm: "user_confirm";
+        plan_created: "plan_created";
+        plan_complete: "plan_complete";
+        review_verdict: "review_verdict";
+        agent_signal: "agent_signal";
+    }>;
+    plan_name: z.ZodOptional<z.ZodString>;
+    keywords: z.ZodOptional<z.ZodArray<z.ZodString>>;
+}, z.core.$strip>;
+/**
+ * Zod schema for artifact references.
+ */
+export declare const ArtifactRefSchema: z.ZodObject<{
+    name: z.ZodString;
+    description: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+/**
+ * Zod schema for step artifact declarations.
+ */
+export declare const StepArtifactsSchema: z.ZodObject<{
+    inputs: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        name: z.ZodString;
+        description: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>>>;
+    outputs: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        name: z.ZodString;
+        description: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>>>;
+}, z.core.$strip>;
+/**
+ * Zod schema for a workflow step definition.
+ */
+export declare const WorkflowStepSchema: z.ZodObject<{
+    id: z.ZodString;
+    name: z.ZodString;
+    type: z.ZodEnum<{
+        interactive: "interactive";
+        autonomous: "autonomous";
+        gate: "gate";
+    }>;
+    agent: z.ZodString;
+    prompt: z.ZodString;
+    completion: z.ZodObject<{
+        method: z.ZodEnum<{
+            user_confirm: "user_confirm";
+            plan_created: "plan_created";
+            plan_complete: "plan_complete";
+            review_verdict: "review_verdict";
+            agent_signal: "agent_signal";
+        }>;
+        plan_name: z.ZodOptional<z.ZodString>;
+        keywords: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    }, z.core.$strip>;
+    artifacts: z.ZodOptional<z.ZodObject<{
+        inputs: z.ZodOptional<z.ZodArray<z.ZodObject<{
+            name: z.ZodString;
+            description: z.ZodOptional<z.ZodString>;
+        }, z.core.$strip>>>;
+        outputs: z.ZodOptional<z.ZodArray<z.ZodObject<{
+            name: z.ZodString;
+            description: z.ZodOptional<z.ZodString>;
+        }, z.core.$strip>>>;
+    }, z.core.$strip>>;
+    on_reject: z.ZodOptional<z.ZodEnum<{
+        pause: "pause";
+        fail: "fail";
+    }>>;
+}, z.core.$strip>;
+/**
+ * Zod schema for a complete workflow definition file.
+ */
+export declare const WorkflowDefinitionSchema: z.ZodObject<{
+    name: z.ZodString;
+    description: z.ZodOptional<z.ZodString>;
+    version: z.ZodNumber;
+    steps: z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        name: z.ZodString;
+        type: z.ZodEnum<{
+            interactive: "interactive";
+            autonomous: "autonomous";
+            gate: "gate";
+        }>;
+        agent: z.ZodString;
+        prompt: z.ZodString;
+        completion: z.ZodObject<{
+            method: z.ZodEnum<{
+                user_confirm: "user_confirm";
+                plan_created: "plan_created";
+                plan_complete: "plan_complete";
+                review_verdict: "review_verdict";
+                agent_signal: "agent_signal";
+            }>;
+            plan_name: z.ZodOptional<z.ZodString>;
+            keywords: z.ZodOptional<z.ZodArray<z.ZodString>>;
+        }, z.core.$strip>;
+        artifacts: z.ZodOptional<z.ZodObject<{
+            inputs: z.ZodOptional<z.ZodArray<z.ZodObject<{
+                name: z.ZodString;
+                description: z.ZodOptional<z.ZodString>;
+            }, z.core.$strip>>>;
+            outputs: z.ZodOptional<z.ZodArray<z.ZodObject<{
+                name: z.ZodString;
+                description: z.ZodOptional<z.ZodString>;
+            }, z.core.$strip>>>;
+        }, z.core.$strip>>;
+        on_reject: z.ZodOptional<z.ZodEnum<{
+            pause: "pause";
+            fail: "fail";
+        }>>;
+    }, z.core.$strip>>;
+}, z.core.$strip>;

package/dist/features/workflow/storage.d.ts

@@ -0,0 +1,51 @@
+import type { WorkflowDefinition, WorkflowInstance, ActiveInstancePointer } from "./types";
+/**
+ * Generate a unique instance ID.
+ * Format: wf_{8 random hex chars} (e.g., "wf_a1b2c3d4").
+ */
+export declare function generateInstanceId(): string;
+/**
+ * Generate a URL-safe slug from a goal string.
+ * Lowercase, spaces to hyphens, strip non-alphanumeric, truncate to 50 chars.
+ */
+export declare function generateSlug(goal: string): string;
+/**
+ * Create a fresh WorkflowInstance for a definition + goal.
+ */
+export declare function createWorkflowInstance(definition: WorkflowDefinition, definitionPath: string, goal: string, sessionId: string): WorkflowInstance;
+/**
+ * Read a workflow instance by ID. Returns null if not found or invalid.
+ */
+export declare function readWorkflowInstance(directory: string, instanceId: string): WorkflowInstance | null;
+/**
+ * Write a workflow instance to its state directory.
+ * Creates directories as needed.
+ */
+export declare function writeWorkflowInstance(directory: string, instance: WorkflowInstance): boolean;
+/**
+ * Read the active instance pointer. Returns null if no active instance.
+ */
+export declare function readActiveInstance(directory: string): ActiveInstancePointer | null;
+/**
+ * Set the active instance pointer.
+ */
+export declare function setActiveInstance(directory: string, instanceId: string): boolean;
+/**
+ * Clear the active instance pointer (without deleting the instance).
+ */
+export declare function clearActiveInstance(directory: string): boolean;
+/**
+ * Get the active workflow instance (resolves pointer -> reads instance).
+ * Returns null if no active instance or instance not found.
+ */
+export declare function getActiveWorkflowInstance(directory: string): WorkflowInstance | null;
+/**
+ * List all instance IDs (for status/history commands).
+ * Returns IDs sorted alphabetically.
+ */
+export declare function listInstances(directory: string): string[];
+/**
+ * Append a session ID to an instance's session_ids.
+ * Returns the updated instance, or null if the instance doesn't exist.
+ */
+export declare function appendInstanceSessionId(directory: string, instanceId: string, sessionId: string): WorkflowInstance | null;

package/dist/features/workflow/types.d.ts

@@ -0,0 +1,142 @@
+/**
+ * Step execution types: interactive (needs user input), autonomous (runs without user),
+ * gate (requires APPROVE/REJECT verdict).
+ */
+export type StepType = "interactive" | "autonomous" | "gate";
+/**
+ * How a step's completion is detected.
+ */
+export type CompletionMethod = "user_confirm" | "plan_created" | "plan_complete" | "review_verdict" | "agent_signal";
+/**
+ * Per-step status in a workflow instance.
+ */
+export type StepStatus = "pending" | "active" | "awaiting_user" | "completed" | "failed" | "skipped";
+/**
+ * Instance-level workflow status.
+ */
+export type WorkflowStatus = "running" | "paused" | "completed" | "failed" | "cancelled";
+/**
+ * What happens when a gate step rejects.
+ */
+export type OnRejectAction = "pause" | "fail";
+/**
+ * Reference to an artifact that a step consumes or produces.
+ */
+export interface ArtifactRef {
+    name: string;
+    description?: string;
+}
+/**
+ * Artifact input/output declarations for a step.
+ */
+export interface StepArtifacts {
+    inputs?: ArtifactRef[];
+    outputs?: ArtifactRef[];
+}
+/**
+ * Configuration for how a step's completion is detected.
+ */
+export interface CompletionConfig {
+    method: CompletionMethod;
+    /** For plan_created/plan_complete: the plan name to check */
+    plan_name?: string;
+    /** For user_confirm: custom keywords to detect */
+    keywords?: string[];
+}
+/**
+ * A single step in a workflow definition (template).
+ */
+export interface WorkflowStepDefinition {
+    /** Unique step ID within the workflow (e.g., "gather", "plan-review") */
+    id: string;
+    /** Human-readable step name */
+    name: string;
+    /** Step execution type */
+    type: StepType;
+    /** Agent to activate for this step */
+    agent: string;
+    /** Prompt template with {{instance.goal}}, {{artifacts.X}} variables */
+    prompt: string;
+    /** How to detect step completion */
+    completion: CompletionConfig;
+    /** Artifact declarations */
+    artifacts?: StepArtifacts;
+    /** For gate steps: what to do on reject */
+    on_reject?: OnRejectAction;
+}
+/**
+ * A workflow definition (reusable template).
+ * Stored as JSONC in .opencode/workflows/ or ~/.config/opencode/workflows/.
+ */
+export interface WorkflowDefinition {
+    /** Workflow name matching the filename (e.g., "secure-feature") */
+    name: string;
+    /** Human-readable description */
+    description?: string;
+    /** Schema version for future migration */
+    version: number;
+    /** Ordered list of steps */
+    steps: WorkflowStepDefinition[];
+}
+/**
+ * Per-step state in a workflow instance.
+ */
+export interface StepState {
+    /** Step ID matching the definition */
+    id: string;
+    /** Current step status */
+    status: StepStatus;
+    /** ISO timestamp when the step became active */
+    started_at?: string;
+    /** ISO timestamp when the step completed/failed/skipped */
+    completed_at?: string;
+    /** For gate steps: the verdict */
+    verdict?: "approve" | "reject";
+    /** Error message if failed */
+    error?: string;
+    /** Artifacts produced by this step */
+    artifacts?: Record<string, string>;
+    /** Summary of what this step produced (for context threading) */
+    summary?: string;
+}
+/**
+ * A workflow instance — a specific execution of a workflow definition,
+ * bound to a user goal with accumulated artifacts and step states.
+ */
+export interface WorkflowInstance {
+    /** Unique instance ID (e.g., "wf_a1b2c3d4") */
+    instance_id: string;
+    /** ID of the workflow definition (matches definition name) */
+    definition_id: string;
+    /** Human-readable workflow name */
+    definition_name: string;
+    /** Path to the workflow definition file */
+    definition_path: string;
+    /** The user's goal — what they're trying to accomplish */
+    goal: string;
+    /** URL-safe slug derived from the goal (for plan filenames, etc.) */
+    slug: string;
+    /** Current workflow-level status */
+    status: WorkflowStatus;
+    /** ISO timestamp when the instance was created */
+    started_at: string;
+    /** ISO timestamp when the instance completed/failed/cancelled */
+    ended_at?: string;
+    /** Session IDs that have participated in this instance */
+    session_ids: string[];
+    /** ID of the currently active step */
+    current_step_id: string;
+    /** Per-step state */
+    steps: Record<string, StepState>;
+    /** Accumulated artifacts from completed steps (name -> value) */
+    artifacts: Record<string, string>;
+    /** Why the workflow is paused (if paused) */
+    pause_reason?: string;
+}
+/**
+ * Pointer file content — tracks which instance is currently active.
+ * Stored at .weave/workflows/active-instance.json.
+ */
+export interface ActiveInstancePointer {
+    instance_id: string;
+}

package/dist/hooks/create-hooks.d.ts

@@ -29,6 +29,12 @@ export declare function createHooks(args: {
     patternMdOnly: typeof checkPatternWrite | null;
     startWork: ((promptText: string, sessionId: string) => import("./start-work-hook").StartWorkResult) | null;
     workContinuation: ((sessionId: string) => import("./work-continuation").ContinuationResult) | null;
+    workflowStart: ((promptText: string, sessionId: string) => import("../features/workflow").WorkflowHookResult) | null;
+    workflowContinuation: ((sessionId: string, lastAssistantMessage?: string, lastUserMessage?: string) => {
+        continuationPrompt: string | null;
+        switchAgent: string | null;
+    }) | null;
+    workflowCommand: ((message: string) => import("../features/workflow").WorkflowCommandResult) | null;
     verificationReminder: typeof buildVerificationReminder | null;
     analyticsEnabled: boolean;
 };