agentweaver 0.1.2 → 0.1.3

package/dist/jira.js

@@ -1,5 +1,6 @@
-import { existsSync } from "node:fs";
+import { existsSync, mkdirSync } from "node:fs";
 import { writeFile } from "node:fs/promises";
+import path from "node:path";
 import { TaskRunnerError } from "./errors.js";
 const ISSUE_KEY_RE = /^[A-Z][A-Z0-9_]*-[0-9]+$/;
 export function extractIssueKey(jiraRef) {
@@ -47,6 +48,7 @@ export async function fetchJiraIssue(jiraApiUrl, jiraTaskFile) {
         throw new TaskRunnerError(`Failed to fetch Jira issue: HTTP ${response.status}`);
     }
     const body = Buffer.from(await response.arrayBuffer());
+    mkdirSync(path.dirname(jiraTaskFile), { recursive: true });
     await writeFile(jiraTaskFile, body);
 }
 export function requireJiraTaskFile(jiraTaskFile) {

package/dist/pipeline/auto-flow.js

@@ -0,0 +1,9 @@
+import { loadDeclarativeFlow } from "./declarative-flows.js";
+let cachedAutoFlow = null;
+export function loadAutoFlow() {
+    if (cachedAutoFlow) {
+        return cachedAutoFlow;
+    }
+    cachedAutoFlow = loadDeclarativeFlow("auto.json");
+    return cachedAutoFlow;
+}

package/dist/pipeline/context.js

@@ -1,5 +1,6 @@
 import process from "node:process";
 import { getOutputAdapter } from "../tui.js";
+import { createNodeRegistry } from "./node-registry.js";
 import { createExecutorRegistry } from "./registry.js";
 export function createPipelineContext(input) {
     return {
@@ -12,6 +13,7 @@ export function createPipelineContext(input) {
         verbose: input.verbose,
         runtime: input.runtime,
         executors: createExecutorRegistry(),
+        nodes: createNodeRegistry(),
         ...(input.setSummary ? { setSummary: input.setSummary } : {}),
     };
 }

package/dist/pipeline/declarative-flow-runner.js

@@ -0,0 +1,246 @@
+import { TaskRunnerError } from "../errors.js";
+import { readFileSync } from "node:fs";
+import { runNodeChecks } from "./checks.js";
+import { runNodeByKind } from "./node-runner.js";
+import { renderPrompt } from "./prompt-runtime.js";
+import { evaluateCondition, resolveParams, resolveValue } from "./value-resolver.js";
+function nowIso8601() {
+    return new Date().toISOString();
+}
+function toJsonValue(value) {
+    if (value === null ||
+        typeof value === "string" ||
+        typeof value === "number" ||
+        typeof value === "boolean") {
+        return value;
+    }
+    if (Array.isArray(value)) {
+        return value.map((candidate) => toJsonValue(candidate));
+    }
+    if (typeof value === "object") {
+        return Object.fromEntries(Object.entries(value).map(([key, candidate]) => [key, toJsonValue(candidate)]));
+    }
+    return String(value);
+}
+function ensureExecutionState(options) {
+    if (options.executionState) {
+        return options.executionState;
+    }
+    return {
+        flowKind: options.flowKind ?? "declarative-flow",
+        flowVersion: options.flowVersion ?? 1,
+        terminated: false,
+        phases: [],
+    };
+}
+function ensurePhaseState(executionState, phase) {
+    let phaseState = executionState.phases.find((candidate) => candidate.id === phase.id);
+    if (!phaseState) {
+        phaseState = {
+            id: phase.id,
+            status: "pending",
+            repeatVars: { ...phase.repeatVars },
+            steps: phase.steps.map((step) => ({
+                id: step.id,
+                status: "pending",
+            })),
+        };
+        executionState.phases.push(phaseState);
+    }
+    return phaseState;
+}
+function toStepOutputs(value) {
+    if (!value || typeof value !== "object" || Array.isArray(value)) {
+        return undefined;
+    }
+    return Object.fromEntries(Object.entries(value).map(([key, candidate]) => [key, toJsonValue(candidate)]));
+}
+function createResolverContext(pipelineContext, flowParams, flowConstants, repeatVars, executionState) {
+    return {
+        flowParams,
+        flowConstants,
+        pipelineContext,
+        repeatVars,
+        ...(executionState ? { executionState } : {}),
+    };
+}
+function resolveExpectation(expectation, context) {
+    if (expectation.kind === "require-artifacts") {
+        const value = resolveValue(expectation.paths, context);
+        if (!Array.isArray(value) || value.some((candidate) => typeof candidate !== "string")) {
+            throw new TaskRunnerError("Expectation 'require-artifacts' must resolve to string[]");
+        }
+        return {
+            kind: "require-artifacts",
+            paths: value,
+            message: expectation.message,
+        };
+    }
+    if (expectation.kind === "require-file") {
+        const value = resolveValue(expectation.path, context);
+        if (typeof value !== "string") {
+            throw new TaskRunnerError("Expectation 'require-file' must resolve to string");
+        }
+        return {
+            kind: "require-file",
+            path: value,
+            message: expectation.message,
+        };
+    }
+    if (expectation.kind === "step-output") {
+        const value = resolveValue(expectation.value, context);
+        if (expectation.equals !== undefined) {
+            const expected = resolveValue(expectation.equals, context);
+            if (value !== expected) {
+                throw new TaskRunnerError(expectation.message);
+            }
+            return {
+                kind: "require-file",
+                path: "",
+                message: expectation.message,
+            };
+        }
+        if (!value) {
+            throw new TaskRunnerError(expectation.message);
+        }
+        return {
+            kind: "require-file",
+            path: "",
+            message: expectation.message,
+        };
+    }
+    throw new TaskRunnerError(`Unsupported expectation kind: ${expectation.kind ?? "unknown"}`);
+}
+function runAfterAction(action, pipelineContext, context) {
+    if (action.kind === "set-summary-from-file") {
+        const value = resolveValue(action.path, context);
+        if (typeof value !== "string") {
+            throw new TaskRunnerError("After action 'set-summary-from-file' must resolve to string path");
+        }
+        pipelineContext.setSummary?.(readFileSync(value, "utf8").trim());
+        return;
+    }
+    throw new TaskRunnerError(`Unsupported after action kind: ${action.kind ?? "unknown"}`);
+}
+export async function runExpandedPhase(phase, pipelineContext, flowParams, flowConstants, options = {}) {
+    const executionState = ensureExecutionState(options);
+    const phaseState = ensurePhaseState(executionState, phase);
+    const phaseContext = createResolverContext(pipelineContext, flowParams, flowConstants, phase.repeatVars, executionState);
+    if (executionState.terminated) {
+        phaseState.status = "skipped";
+        await options.onStateChange?.(executionState);
+        return {
+            id: phase.id,
+            status: "skipped",
+            stopped: true,
+            executionState,
+            steps: phase.steps.map((step) => ({ id: step.id, status: "skipped" })),
+        };
+    }
+    if (!evaluateCondition(phase.when, phaseContext)) {
+        phaseState.status = "skipped";
+        phaseState.startedAt ??= nowIso8601();
+        phaseState.finishedAt = nowIso8601();
+        phaseState.steps.forEach((step) => {
+            step.status = "skipped";
+            step.finishedAt = nowIso8601();
+        });
+        await options.onStateChange?.(executionState);
+        return {
+            id: phase.id,
+            status: "skipped",
+            stopped: false,
+            executionState,
+            steps: phase.steps.map((step) => ({ id: step.id, status: "skipped" })),
+        };
+    }
+    phaseState.status = "running";
+    phaseState.startedAt ??= nowIso8601();
+    await options.onStateChange?.(executionState);
+    const steps = [];
+    for (const [stepIndex, step] of phase.steps.entries()) {
+        await options.onStepStart?.(phase, step);
+        const stepContext = createResolverContext(pipelineContext, flowParams, flowConstants, step.repeatVars, executionState);
+        const stepState = phaseState.steps[stepIndex];
+        if (!stepState) {
+            throw new TaskRunnerError(`Missing execution state for step '${step.id}' in phase '${phase.id}'`);
+        }
+        stepState.status = "running";
+        stepState.startedAt ??= nowIso8601();
+        await options.onStateChange?.(executionState);
+        if (!evaluateCondition(step.when, stepContext)) {
+            stepState.status = "skipped";
+            stepState.finishedAt = nowIso8601();
+            await options.onStateChange?.(executionState);
+            steps.push({ id: step.id, status: "skipped" });
+            continue;
+        }
+        const params = resolveParams(step.params, stepContext);
+        if (step.prompt) {
+            params.prompt = renderPrompt(step.prompt, stepContext);
+        }
+        const result = await runNodeByKind(step.node, pipelineContext, params, { skipChecks: step.expect !== undefined });
+        stepState.value = toJsonValue(result.value);
+        const stepOutputs = toStepOutputs(result.value);
+        if (stepOutputs) {
+            stepState.outputs = stepOutputs;
+        }
+        else {
+            delete stepState.outputs;
+        }
+        if (step.expect) {
+            const nodeChecks = step.expect
+                .filter((expectation) => evaluateCondition(expectation.when, stepContext))
+                .flatMap((expectation) => {
+                if (expectation.kind === "step-output") {
+                    resolveExpectation(expectation, stepContext);
+                    return [];
+                }
+                return [resolveExpectation(expectation, stepContext)];
+            });
+            runNodeChecks(nodeChecks);
+        }
+        if (step.after) {
+            step.after.filter((action) => evaluateCondition(action.when, stepContext)).forEach((action) => {
+                runAfterAction(action, pipelineContext, stepContext);
+            });
+        }
+        const stopFlow = step.stopFlowIf ? evaluateCondition(step.stopFlowIf, stepContext) : false;
+        stepState.status = "done";
+        stepState.finishedAt = nowIso8601();
+        stepState.stopFlow = stopFlow;
+        await options.onStateChange?.(executionState);
+        steps.push({ id: step.id, status: "done", ...(stepState.outputs ? { outputs: stepState.outputs } : {}) });
+        if (stopFlow) {
+            executionState.terminated = true;
+            executionState.terminationReason = `Stopped by ${phase.id}:${step.id}`;
+            phaseState.status = "done";
+            phaseState.finishedAt = nowIso8601();
+            await options.onStateChange?.(executionState);
+            return {
+                id: phase.id,
+                status: "stopped",
+                stopped: true,
+                executionState,
+                steps,
+            };
+        }
+    }
+    phaseState.status = "done";
+    phaseState.finishedAt = nowIso8601();
+    await options.onStateChange?.(executionState);
+    return {
+        id: phase.id,
+        status: "done",
+        stopped: false,
+        executionState,
+        steps,
+    };
+}
+export function findPhaseById(phases, phaseId) {
+    const phase = phases.find((candidate) => candidate.id === phaseId);
+    if (!phase) {
+        throw new TaskRunnerError(`Unknown expanded phase id: ${phaseId}`);
+    }
+    return phase;
+}

package/dist/pipeline/declarative-flows.js

@@ -0,0 +1,24 @@
+import { createNodeRegistry } from "./node-registry.js";
+import { compileFlowSpec } from "./spec-compiler.js";
+import { loadFlowSpecSync } from "./spec-loader.js";
+import { validateExpandedPhases, validateFlowSpec } from "./spec-validator.js";
+const cache = new Map();
+export function loadDeclarativeFlow(fileName) {
+    const cached = cache.get(fileName);
+    if (cached) {
+        return cached;
+    }
+    const spec = loadFlowSpecSync(fileName);
+    const nodeRegistry = createNodeRegistry();
+    validateFlowSpec(spec, nodeRegistry);
+    const phases = compileFlowSpec(spec);
+    validateExpandedPhases(phases);
+    const loaded = {
+        kind: spec.kind,
+        version: spec.version,
+        constants: spec.constants ?? {},
+        phases,
+    };
+    cache.set(fileName, loaded);
+    return loaded;
+}