@parcha/agentrun-pi 0.1.0-beta.1

package/dist/cli.js

@@ -0,0 +1,68 @@
+#!/usr/bin/env node
+import { readFile } from "node:fs/promises";
+import { resolve } from "node:path";
+import { pathToFileURL } from "node:url";
+import { runWorkflow, validateWorkflow } from "@parcha/agentrun-dsl";
+import { authorWorkflow } from "./author.js";
+import { createPiRunner } from "./runner.js";
+const help = `Usage:
+  agentrun-pi validate workflow.json [--inputs key1,key2]
+  agentrun-pi author --config ./pi.config.mjs --out ./candidates "Describe the workflow"
+  agentrun-pi run --config ./pi.config.mjs workflow.json input.json
+
+Config is trusted JavaScript exporting default PiRunnerOptions, optionally deps (Jev/effect adapters).
+Author saves candidates; it does not execute or activate them.
+Validate may execute code probes. Run executes trusted workflow code and exits 2 on escalation.
+Model and authentication must be configured explicitly. No shell/filesystem tools are enabled by default.`;
+async function main(args) {
+    const command = args.shift();
+    if (!command || command === "--help" || command === "help") {
+        console.log(help);
+        return;
+    }
+    const flag = (name) => {
+        const index = args.indexOf(name);
+        if (index < 0)
+            return undefined;
+        const value = args[index + 1];
+        if (!value || value.startsWith("--"))
+            throw new Error(`Missing value for ${name}`);
+        args.splice(index, 2);
+        return value;
+    };
+    const configPath = flag("--config");
+    const outputDir = flag("--out") ?? "./candidates";
+    const inputKeys = (flag("--inputs") ?? "").split(",").filter(Boolean);
+    if (command === "validate") {
+        if (args.length !== 1)
+            throw new Error(help);
+        const candidate = JSON.parse(await readFile(args[0], "utf8"));
+        const verdict = validateWorkflow(candidate, { inputKeys: inputKeys.length ? inputKeys : undefined });
+        console.log(JSON.stringify(verdict, null, 2));
+        if (!verdict.ok)
+            process.exitCode = 1;
+        return;
+    }
+    if (command !== "author" && command !== "run")
+        throw new Error(help);
+    if (!configPath)
+        throw new Error("Supply --config with an explicit model and modelRuntime");
+    const config = await import(pathToFileURL(resolve(configPath)).href);
+    if (command === "author") {
+        if (args.length !== 1)
+            throw new Error(help);
+        const authored = await authorWorkflow({ request: args[0], outputDir, inputKeys, pi: config.default });
+        console.log(JSON.stringify({ path: authored.path, candidates: authored.candidates, checks: authored.checks }, null, 2));
+    }
+    else {
+        if (args.length !== 2)
+            throw new Error(help);
+        const workflow = JSON.parse(await readFile(args[0], "utf8"));
+        const input = JSON.parse(await readFile(args[1], "utf8"));
+        const result = await runWorkflow(workflow, input, { ...config.deps, runNode: createPiRunner(config.default) });
+        console.log(JSON.stringify(result, null, 2));
+        if (result.status === "escalated")
+            process.exitCode = 2;
+    }
+}
+main(process.argv.slice(2)).catch(error => { console.error(error instanceof Error ? error.message : String(error)); process.exitCode = 1; });

package/dist/demo-data.d.ts

@@ -0,0 +1,361 @@
+export declare const demoData: {
+    workflow: {
+        v: number;
+        name: string;
+        schemas: {
+            Question: {
+                $schema: string;
+                type: string;
+                properties: {
+                    question: {
+                        type: string;
+                        minLength: number;
+                    };
+                };
+                required: string[];
+                additionalProperties: boolean;
+            };
+            Plan: {
+                $schema: string;
+                type: string;
+                properties: {
+                    questions: {
+                        minItems: number;
+                        maxItems: number;
+                        type: string;
+                        items: {
+                            type: string;
+                            minLength: number;
+                        };
+                    };
+                };
+                required: string[];
+                additionalProperties: boolean;
+            };
+            Finding: {
+                $schema: string;
+                type: string;
+                properties: {
+                    question: {
+                        type: string;
+                    };
+                    answer: {
+                        type: string;
+                    };
+                    sources: {
+                        minItems: number;
+                        type: string;
+                        items: {
+                            type: string;
+                            properties: {
+                                id: {
+                                    type: string;
+                                };
+                                text: {
+                                    type: string;
+                                };
+                            };
+                            required: string[];
+                            additionalProperties: boolean;
+                        };
+                    };
+                };
+                required: string[];
+                additionalProperties: boolean;
+            };
+            Report: {
+                $schema: string;
+                type: string;
+                properties: {
+                    answer: {
+                        type: string;
+                    };
+                    findings: {
+                        minItems: number;
+                        type: string;
+                        items: {
+                            type: string;
+                            properties: {
+                                question: {
+                                    type: string;
+                                };
+                                answer: {
+                                    type: string;
+                                };
+                                sources: {
+                                    minItems: number;
+                                    type: string;
+                                    items: {
+                                        type: string;
+                                        properties: {
+                                            id: {
+                                                type: string;
+                                            };
+                                            text: {
+                                                type: string;
+                                            };
+                                        };
+                                        required: string[];
+                                        additionalProperties: boolean;
+                                    };
+                                };
+                            };
+                            required: string[];
+                            additionalProperties: boolean;
+                        };
+                    };
+                };
+                required: string[];
+                additionalProperties: boolean;
+            };
+        };
+        input: {
+            schemaId: string;
+        };
+        output: {
+            schemaId: string;
+            path: string;
+        };
+        root: {
+            node: string;
+            steps: ({
+                node: string;
+                label: string;
+                instructions: string;
+                state: {
+                    question: string;
+                    findings?: undefined;
+                };
+                out: string;
+                as: string;
+                itemsPath?: undefined;
+                maxConcurrency?: undefined;
+                resultPath?: undefined;
+                body?: undefined;
+            } | {
+                node: string;
+                label: string;
+                itemsPath: string;
+                as: string;
+                maxConcurrency: number;
+                resultPath: string;
+                body: {
+                    node: string;
+                    label: string;
+                    workflow: {
+                        v: number;
+                        name: string;
+                        schemas: {
+                            Question: {
+                                $schema: string;
+                                type: string;
+                                properties: {
+                                    question: {
+                                        type: string;
+                                        minLength: number;
+                                    };
+                                };
+                                required: string[];
+                                additionalProperties: boolean;
+                            };
+                            Sources: {
+                                $schema: string;
+                                type: string;
+                                properties: {
+                                    sources: {
+                                        type: string;
+                                        items: {
+                                            type: string;
+                                            properties: {
+                                                id: {
+                                                    type: string;
+                                                };
+                                                text: {
+                                                    type: string;
+                                                };
+                                            };
+                                            required: string[];
+                                            additionalProperties: boolean;
+                                        };
+                                    };
+                                };
+                                required: string[];
+                                additionalProperties: boolean;
+                            };
+                            Finding: {
+                                $schema: string;
+                                type: string;
+                                properties: {
+                                    question: {
+                                        type: string;
+                                    };
+                                    answer: {
+                                        type: string;
+                                    };
+                                    sources: {
+                                        minItems: number;
+                                        type: string;
+                                        items: {
+                                            type: string;
+                                            properties: {
+                                                id: {
+                                                    type: string;
+                                                };
+                                                text: {
+                                                    type: string;
+                                                };
+                                            };
+                                            required: string[];
+                                            additionalProperties: boolean;
+                                        };
+                                    };
+                                };
+                                required: string[];
+                                additionalProperties: boolean;
+                            };
+                            EvidenceDecision: {
+                                type: string;
+                                additionalProperties: boolean;
+                                required: string[];
+                                properties: {
+                                    answersQuestion: {
+                                        type: string;
+                                        description: string;
+                                        criteria: {
+                                            true: string;
+                                            false: string;
+                                        };
+                                    };
+                                };
+                            };
+                        };
+                        input: {
+                            schemaId: string;
+                        };
+                        output: {
+                            schemaId: string;
+                            path: string;
+                        };
+                        root: {
+                            node: string;
+                            steps: ({
+                                node: string;
+                                label: string;
+                                via: string;
+                                tool: string;
+                                args: {
+                                    question: string;
+                                };
+                                out: string;
+                                as: string;
+                                deadline_s: number;
+                                itemsPath?: undefined;
+                                state?: undefined;
+                                keep?: undefined;
+                                when?: undefined;
+                                kind?: undefined;
+                                stage?: undefined;
+                                summary?: undefined;
+                                instructions?: undefined;
+                            } | {
+                                node: string;
+                                label: string;
+                                itemsPath: string;
+                                state: {
+                                    subquestion: string;
+                                    question?: undefined;
+                                    sources?: undefined;
+                                };
+                                out: string;
+                                as: string;
+                                keep: {
+                                    path: string;
+                                    gte: number;
+                                };
+                                via?: undefined;
+                                tool?: undefined;
+                                args?: undefined;
+                                deadline_s?: undefined;
+                                when?: undefined;
+                                kind?: undefined;
+                                stage?: undefined;
+                                summary?: undefined;
+                                instructions?: undefined;
+                            } | {
+                                node: string;
+                                label: string;
+                                when: {
+                                    predicate: string;
+                                    path: string;
+                                };
+                                kind: string;
+                                stage: string;
+                                summary: string;
+                                via?: undefined;
+                                tool?: undefined;
+                                args?: undefined;
+                                out?: undefined;
+                                as?: undefined;
+                                deadline_s?: undefined;
+                                itemsPath?: undefined;
+                                state?: undefined;
+                                keep?: undefined;
+                                instructions?: undefined;
+                            } | {
+                                node: string;
+                                label: string;
+                                instructions: string;
+                                state: {
+                                    question: string;
+                                    sources: string;
+                                    subquestion?: undefined;
+                                };
+                                out: string;
+                                as: string;
+                                via?: undefined;
+                                tool?: undefined;
+                                args?: undefined;
+                                deadline_s?: undefined;
+                                itemsPath?: undefined;
+                                keep?: undefined;
+                                when?: undefined;
+                                kind?: undefined;
+                                stage?: undefined;
+                                summary?: undefined;
+                            })[];
+                        };
+                    };
+                    input: {
+                        question: string;
+                    };
+                    out: string;
+                    as: string;
+                };
+                instructions?: undefined;
+                state?: undefined;
+                out?: undefined;
+            } | {
+                node: string;
+                label: string;
+                instructions: string;
+                state: {
+                    question: string;
+                    findings: string;
+                };
+                out: string;
+                as: string;
+                itemsPath?: undefined;
+                maxConcurrency?: undefined;
+                resultPath?: undefined;
+                body?: undefined;
+            })[];
+        };
+    };
+    question: string;
+    sources: {
+        id: string;
+        text: string;
+    }[];
+    subquestions: string[];
+    evidenceIds: string[];
+};