stageflow 0.2.0 → 0.3.0

package/dist/tools/emitStageEnvelope.js

@@ -11,6 +11,7 @@
  */
 import { Type } from "typebox";
 import { assertRequiredEnvelope, isAdvancingEnvelope, } from "../envelope/check.js";
+import { normalizeForkChoice } from "../envelope/forkChoice.js";
 import { assertEnvelopePayload, compilePayloadSchema, } from "../envelope/payloadSchema.js";
 function toolResult(text, details, options) {
     return {
@@ -20,7 +21,7 @@ function toolResult(text, details, options) {
         ...(options?.terminate ? { terminate: true } : {}),
     };
 }
-export function createEmitStageEnvelopeTool(capture, payloadSchema) {
+export function createEmitStageEnvelopeTool(capture, payloadSchema, forkEmitContext) {
     const compiledPayload = payloadSchema !== undefined
         ? compilePayloadSchema(payloadSchema)
         : undefined;
@@ -35,6 +36,9 @@ export function createEmitStageEnvelopeTool(capture, payloadSchema) {
             payload: compiledPayload !== undefined
                 ? compiledPayload
                 : Type.Optional(Type.Record(Type.String(), Type.Unknown())),
+            fork_choice: forkEmitContext !== undefined
+                ? Type.Array(Type.String())
+                : Type.Optional(Type.Array(Type.String())),
             stage_id: Type.Optional(Type.String()),
             notes: Type.Optional(Type.String()),
         }),
@@ -43,6 +47,12 @@ export function createEmitStageEnvelopeTool(capture, payloadSchema) {
                 return toolResult("Envelope already accepted; later emits are ignored.", { advancing: isAdvancingEnvelope(capture.envelope), error: "" }, { terminate: true });
             }
             try {
+                if (forkEmitContext !== undefined) {
+                    const record = params;
+                    if (record.status !== "failure") {
+                        normalizeForkChoice(record.fork_choice, "emit", forkEmitContext);
+                    }
+                }
                 const envelope = assertRequiredEnvelope(params);
                 assertEnvelopePayload(envelope, payloadSchema);
                 capture.envelope = envelope;

package/dist/types/envelope.d.ts

@@ -4,6 +4,7 @@ export type StageEnvelope = {
     summary: string;
     artifacts: string[];
     payload?: Record<string, unknown>;
+    fork_choice?: string[];
     stage_id?: string;
     notes?: string;
 };

package/dist/types/forkChoice.d.ts

@@ -0,0 +1,8 @@
+export type ForkChoiceShape = {
+    cardinality: "one" | "subset";
+    allowNone: boolean;
+};
+export type ForkEmitContext = {
+    immediateSuccessorIds: string[];
+    forkShape: ForkChoiceShape | null;
+};

package/dist/types/forkChoice.js

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

package/dist/types/pipeline.d.ts

@@ -1,17 +1,64 @@
+import type { StageConfig, StageGateKind } from "./stage.js";
 export type PipelineConfig = {
     id: string;
     stages: string[];
 };
+export type PipelineForkConfig = {
+    select: "one" | "subset";
+    allow_none: boolean;
+};
 export type PipelineStageRef = {
     id: string;
     needs?: string;
+    fork?: {
+        select: "one" | "subset";
+        allow_none?: boolean;
+    };
+};
+export type PipelineStageYamlEntry = PipelineStageRef & {
+    uses?: string;
+    system_prompt?: string;
+    model?: string;
+    payload_schema?: unknown;
+    gate_kinds?: StageGateKind[];
+    skill?: string;
+};
+export type PipelineIncludeEntry = {
+    local: string;
+};
+export type PipelineFragmentConfig = {
+    include?: PipelineIncludeEntry[];
+    stages?: PipelineStageYamlEntry[];
+};
+export type NormalizedPipelineStageEntry = {
+    id: string;
+    needs?: string;
+    fork?: {
+        select: "one" | "subset";
+        allow_none?: boolean;
+    };
+    body: {
+        kind: "inline";
+        raw: Record<string, unknown>;
+    } | {
+        kind: "uses";
+        path: string;
+        absolutePath: string;
+    };
+    declaringPath: string;
+};
+export type PipelineStageSource = {
+    kind: "inline";
+} | {
+    kind: "file";
+    path: string;
 };
-export type PipelineStageYamlEntry = string | PipelineStageRef;
 export type ResolvedPipelineStageNode = {
     id: string;
     needs: string | null;
     ancestors: string[];
     stageIndex: number;
+    fork?: PipelineForkConfig;
 };
 export type ResolvedPipelineDag = {
     nodes: ResolvedPipelineStageNode[];
@@ -20,6 +67,8 @@ export type ResolvedPipelineDag = {
 };
 export type LoadedPipeline = {
     pipeline: PipelineConfig;
-    stages: import("./stage.js").StageConfig[];
+    stages: StageConfig[];
     dag: ResolvedPipelineDag;
+    pipelinePath: string;
+    stageSources?: Record<string, PipelineStageSource>;
 };

package/dist/types/stageflowManifest.d.ts

@@ -0,0 +1,23 @@
+export type StageflowManifestVersion = 1;
+export type StageflowManifestCatalog = {
+    pipelines: string[];
+    tasks: string[];
+    patterns?: {
+        pipeline?: string;
+        task?: string;
+    };
+    exclude?: string[];
+};
+export type StageflowManifest = {
+    version: StageflowManifestVersion;
+    catalog: StageflowManifestCatalog;
+};
+export type LoadedManifest = {
+    path: string;
+    projectRoot: string;
+    manifest: StageflowManifest;
+    patterns: {
+        pipeline: string;
+        task: string;
+    };
+};

package/dist/types/stageflowManifest.js

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