pi-extensible-workflows 3.1.0 → 3.2.0

package/src/index.ts

@@ -5,6 +5,7 @@ export * from "./validation.js";
 export * from "./registry.js";
 export * from "./execution.js";
 export * from "./host.js";
+export * from "./workflow-artifacts.js";
 export { default } from "./host.js";
 export { acquireSessionLease, hasLiveSessionLease, projectSessionsDirectory, projectStorageKey, RunStore, runsDirectory, SessionLease, structuralPath } from "./persistence.js";
 export type { AwaitingCheckpoint, CompletedOperation, NativeSessionReference, PendingWorkflowDecision, PersistedOwnershipNode, PersistedRun, WorktreeReference } from "./persistence.js";

package/src/types.ts

@@ -73,7 +73,7 @@ export interface AgentSetupSummary { hookNames: readonly string[]; model: ModelS
 export interface AgentAttemptSummary { attempt: number; sessionId: string; sessionFile: string; error?: { code: string; message: string }; accounting: { input: number; output: number; cacheRead: number; cacheWrite: number; cost: number }; setup?: AgentSetupSummary }
 export interface WorkflowWorktreeCreatedEvent extends WorkflowEventBase { owner: string; branch: string; path: string; base: string }
 export interface WorkflowWorktreeReference { readonly path: string; readonly branch: string }
-export interface AgentRecord { id: string; name: string; label?: string; path: string; state: AgentState; parentId?: string; structuralPath?: readonly string[]; parentBreadcrumb?: string; worktreeOwner?: string; role?: string; requestedModel?: string; model: ModelSpec; tools: readonly string[]; attempts: number; attemptDetails?: readonly AgentAttemptSummary[]; accounting?: { input: number; output: number; cacheRead: number; cacheWrite: number; cost: number }; toolCalls?: readonly { id: string; name: string; state: "running" | "completed" | "failed" }[]; activity?: AgentActivity | undefined }
+export interface AgentRecord { id: string; name: string; label?: string; path: string; state: AgentState; parentId?: string; structuralPath?: readonly string[]; resultPath?: string; parentBreadcrumb?: string; worktreeOwner?: string; role?: string; requestedModel?: string; model: ModelSpec; tools: readonly string[]; attempts: number; attemptDetails?: readonly AgentAttemptSummary[]; accounting?: { input: number; output: number; cacheRead: number; cacheWrite: number; cost: number }; toolCalls?: readonly { id: string; name: string; state: "running" | "completed" | "failed" }[]; activity?: AgentActivity | undefined }
 export interface WorkflowRunEvent { type: string; message: string }
 export interface WorkflowRetryProvenance { sourceRunId: string; lineageRootRunId: string; completedPaths: readonly string[]; incompletePaths: readonly string[]; namedWorktrees: readonly string[] }
 export interface WorkflowPhaseRecord { phase: string; afterAgent: number }

package/src/validation.ts

@@ -324,6 +324,32 @@ function workflowCallsWithStructure(program: acorn.Program): Array<{ call: Workf
   visit(program, { execution: "sequential", structure: [] });
   return calls.sort((left, right) => left.call.start - right.call.start);
 }
+function memberCall(node: acorn.AnyNode | undefined, objectName: string, propertyName: string): boolean {
+  if (node?.type !== "CallExpression" || node.callee.type !== "MemberExpression" || node.callee.computed || node.callee.object.type !== "Identifier" || node.callee.object.name !== objectName || node.callee.property.type !== "Identifier") return false;
+  return node.callee.property.name === propertyName;
+}
+function mapCallback(node: acorn.AnyNode): acorn.AnyNode | undefined {
+  if (!memberCall(node, "Promise", "all") && !memberCall(node, "Promise", "allSettled")) return undefined;
+  if (node.type !== "CallExpression") return undefined;
+  const source = node.arguments[0];
+  if (source?.type !== "CallExpression" || source.callee.type !== "MemberExpression" || source.callee.computed || source.callee.property.type !== "Identifier" || !["map", "flatMap"].includes(source.callee.property.name)) return undefined;
+  const callback = source.arguments[0];
+  return callback?.type === "ArrowFunctionExpression" || callback?.type === "FunctionExpression" ? callback : undefined;
+}
+function hasUnscopedAgent(node: acorn.AnyNode, scoped = false): boolean {
+  const operation = workflowCallKind(node);
+  if (operation === "agent") return !scoped;
+  const nestedScope = scoped || operation === "parallel" || operation === "pipeline";
+  return astChildren(node).some((child) => hasUnscopedAgent(child, nestedScope));
+}
+function validateObviousConcurrentAgentCalls(program: acorn.Program): void {
+  const visit = (node: acorn.AnyNode): void => {
+    const callback = mapCallback(node);
+    if (callback && hasUnscopedAgent(callback)) fail("INVALID_METADATA", "Promise.all/map agent fan-out cannot prove stable call-site identity; use parallel(...) or pipeline(...)");
+    for (const child of astChildren(node)) visit(child);
+  };
+  visit(program);
+}
 function validateDirectPrimitiveReferences(program: acorn.AnyNode, name: string): void {
   const visit = (node: acorn.AnyNode, parent?: acorn.AnyNode): void => {
     if (node.type === "Identifier" && node.name === name) {
@@ -606,6 +632,7 @@ export function preflight(script: string, capabilities: PreflightCapabilities, s
   validateDirectPrimitiveReferences(program, "shell");
   for (const [index, schema] of schemas.entries()) validateSchema(schema, `schema[${String(index)}]`);
   const calls = workflowCalls(program);
+  validateObviousConcurrentAgentCalls(program);
   const phases = calls.filter((call) => call.callee.name === "phase").map((call) => literalString(call.arguments[0])).filter((phase): phase is string => phase !== undefined);
   for (const call of calls) {
     const operation = call.callee.name;

package/src/workflow-artifacts.ts

@@ -0,0 +1,34 @@
+import { spawn } from "node:child_process";
+import { mkdtemp, rm, writeFile } from "node:fs/promises";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import type { JsonValue } from "./types.js";
+
+export interface WorkflowArtifact { extension: ".js" | ".json" | ".md"; content: string }
+export type WorkflowTui = { stop(): void; start(): void; requestRender(force?: boolean): void };
+
+export function workflowScriptArtifact(script: string): WorkflowArtifact { return { extension: ".js", content: script }; }
+export function workflowResultArtifact(value: JsonValue): WorkflowArtifact { return typeof value === "string" ? { extension: ".md", content: value } : { extension: ".json", content: `${JSON.stringify(value, null, 2)}\n` }; }
+
+async function spawnWorkflowEditor(command: string, path: string): Promise<number | null> {
+  const [editor, ...editorArgs] = command.split(" ");
+  if (!editor) return null;
+  return new Promise((resolve) => {
+    try {
+      const child = spawn(editor, [...editorArgs, path], { stdio: "inherit", shell: process.platform === "win32" });
+      child.once("error", () => { resolve(null); });
+      child.once("close", (code) => { resolve(code); });
+    } catch { resolve(null); }
+  });
+}
+
+export async function openWorkflowArtifact(tui: WorkflowTui, command: string, artifact: WorkflowArtifact): Promise<number | null> {
+  const directory = await mkdtemp(join(tmpdir(), "pi-workflow-editor-"));
+  const path = join(directory, `artifact${artifact.extension}`);
+  try {
+    await writeFile(path, artifact.content, { encoding: "utf8", mode: 0o600 });
+    tui.stop();
+    try { return await spawnWorkflowEditor(command, path); }
+    finally { tui.start(); tui.requestRender(true); }
+  } finally { await rm(directory, { recursive: true, force: true }); }
+}