agentweaver 0.1.14 → 0.1.16

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

@@ -1,9 +1,12 @@
+import { randomUUID } from "node:crypto";
+import { existsSync, readFileSync } from "node:fs";
+import path from "node:path";
+import { buildLogicalKeyForPayload } from "../artifact-manifest.js";
 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";
+import { renderPrompt, resolvePromptBindingInputs } from "./prompt-runtime.js";
+import { collectResolvedArtifactPathCandidates, collectResolvedPromptArtifactPathCandidates, evaluateCondition, resolveParams, resolveValue, } from "./value-resolver.js";
 function nowIso8601() {
     return new Date().toISOString();
 }
@@ -24,12 +27,17 @@ function toJsonValue(value) {
 }
 function ensureExecutionState(options) {
     if (options.executionState) {
+        options.executionState.runId ??= randomUUID();
+        options.executionState.publicationRunId ??= randomUUID();
         return options.executionState;
     }
     return {
+        runId: randomUUID(),
+        publicationRunId: randomUUID(),
         flowKind: options.flowKind ?? "declarative-flow",
         flowVersion: options.flowVersion ?? 1,
         terminated: false,
+        terminationOutcome: "success",
         phases: [],
     };
 }
@@ -138,6 +146,129 @@ function runAfterAction(action, pipelineContext, context) {
     }
     throw new TaskRunnerError(`Unsupported after action kind: ${action.kind ?? "unknown"}`);
 }
+function shouldPublishManifest(output) {
+    return output.manifest?.publish === true;
+}
+function resolveOutputLogicalKey(scopeKey, output) {
+    return output.manifest?.logicalKey ?? buildLogicalKeyForPayload(scopeKey, output.path);
+}
+function validateDistinctLogicalKeys(scopeKey, phaseId, stepId, outputs) {
+    const pathsByLogicalKey = new Map();
+    for (const output of outputs) {
+        const logicalKey = resolveOutputLogicalKey(scopeKey, output);
+        const existingPath = pathsByLogicalKey.get(logicalKey);
+        if (existingPath && existingPath !== output.path) {
+            throw new TaskRunnerError(`Step '${phaseId}:${stepId}' produced duplicate logical_key '${logicalKey}' for outputs '${existingPath}' and '${output.path}'.`);
+        }
+        pathsByLogicalKey.set(logicalKey, output.path);
+    }
+}
+function producerMetadata(resultValue) {
+    if (!resultValue || typeof resultValue !== "object" || Array.isArray(resultValue)) {
+        return {};
+    }
+    const record = resultValue;
+    return {
+        ...(typeof record["executor"] === "string" ? { executor: record["executor"] } : {}),
+        ...(typeof record["model"] === "string" ? { model: record["model"] } : {}),
+    };
+}
+function collectNestedPublishedArtifacts(resultValue) {
+    if (!resultValue || typeof resultValue !== "object" || Array.isArray(resultValue)) {
+        return [];
+    }
+    const rawArtifacts = resultValue["publishedArtifacts"];
+    if (!Array.isArray(rawArtifacts)) {
+        return [];
+    }
+    return rawArtifacts.filter((artifact) => {
+        if (!artifact || typeof artifact !== "object" || Array.isArray(artifact)) {
+            return false;
+        }
+        const record = artifact;
+        return typeof record["artifact_id"] === "string" && typeof record["payload_path"] === "string";
+    });
+}
+function mergePublishedArtifacts(...groups) {
+    const merged = [];
+    const seen = new Set();
+    for (const group of groups) {
+        for (const artifact of group) {
+            const key = artifact.artifact_id;
+            if (seen.has(key)) {
+                continue;
+            }
+            seen.add(key);
+            merged.push(artifact);
+        }
+    }
+    return merged;
+}
+function normalizeCandidatePath(value) {
+    return path.resolve(value);
+}
+function collectLineageInputs(values, artifactPaths, pipelineContext, excludedPaths = []) {
+    const seen = new Set();
+    const inputs = [];
+    const excluded = new Set(Array.from(excludedPaths, (candidate) => normalizeCandidatePath(candidate)));
+    const addInput = (input) => {
+        if (excluded.has(normalizeCandidatePath(input.path))) {
+            return;
+        }
+        const key = `${input.source}:${input.artifact_id ?? ""}:${normalizeCandidatePath(input.path)}`;
+        if (seen.has(key)) {
+            return;
+        }
+        seen.add(key);
+        inputs.push(input);
+    };
+    for (const artifactPath of artifactPaths) {
+        addInput(pipelineContext.runtime.artifactRegistry.resolveLineageInputFromPath(pipelineContext.issueKey, artifactPath));
+    }
+    const visit = (value) => {
+        if (Array.isArray(value)) {
+            value.forEach((item) => visit(item));
+            return;
+        }
+        if (!value || typeof value !== "object") {
+            return;
+        }
+        const record = value;
+        if (typeof record["artifact_id"] === "string" && typeof record["payload_path"] === "string") {
+            const payloadPath = String(record["payload_path"]);
+            if (!excluded.has(normalizeCandidatePath(payloadPath))) {
+                addInput({
+                    source: "manifest",
+                    path: payloadPath,
+                    artifact_id: String(record["artifact_id"]),
+                    ...(typeof record["logical_key"] === "string" ? { logical_key: String(record["logical_key"]) } : {}),
+                    ...(typeof record["schema_id"] === "string" ? { schema_id: String(record["schema_id"]) } : {}),
+                    ...(typeof record["schema_version"] === "number" ? { schema_version: Number(record["schema_version"]) } : {}),
+                });
+            }
+        }
+        for (const candidate of Object.values(record)) {
+            visit(candidate);
+        }
+    };
+    values.forEach((value) => visit(value));
+    return inputs.sort((left, right) => left.path.localeCompare(right.path));
+}
+function mergeLineageInputs(...groups) {
+    const seen = new Set();
+    const merged = [];
+    for (const group of groups) {
+        for (const input of group) {
+            const key = `${input.source}:${input.artifact_id ?? ""}:${normalizeCandidatePath(input.path)}`;
+            if (seen.has(key)) {
+                continue;
+            }
+            seen.add(key);
+            merged.push(input);
+        }
+    }
+    return merged.sort((left, right) => left.path.localeCompare(right.path));
+}
 export async function runExpandedPhase(phase, pipelineContext, flowParams, flowConstants, options = {}) {
     const executionState = ensureExecutionState(options);
     const phaseState = ensurePhaseState(executionState, phase);
@@ -153,6 +284,9 @@ export async function runExpandedPhase(phase, pipelineContext, flowParams, flowC
                 id: step.id,
                 status: phaseState.steps[stepIndex]?.status === "skipped" ? "skipped" : "done",
                 ...(phaseState.steps[stepIndex]?.outputs ? { outputs: phaseState.steps[stepIndex]?.outputs } : {}),
+                ...(phaseState.steps[stepIndex]?.publishedArtifacts
+                    ? { publishedArtifacts: phaseState.steps[stepIndex]?.publishedArtifacts }
+                    : {}),
             })),
         };
     }
@@ -206,7 +340,12 @@ export async function runExpandedPhase(phase, pipelineContext, flowParams, flowC
             throw new TaskRunnerError(`Missing execution state for step '${step.id}' in phase '${phase.id}'`);
         }
         if (stepState.status === "done" || stepState.status === "skipped") {
-            steps.push({ id: step.id, status: stepState.status, ...(stepState.outputs ? { outputs: stepState.outputs } : {}) });
+            steps.push({
+                id: step.id,
+                status: stepState.status,
+                ...(stepState.outputs ? { outputs: stepState.outputs } : {}),
+                ...(stepState.publishedArtifacts ? { publishedArtifacts: stepState.publishedArtifacts } : {}),
+            });
             continue;
         }
         stepState.status = "running";
@@ -220,10 +359,23 @@ export async function runExpandedPhase(phase, pipelineContext, flowParams, flowC
             continue;
         }
         const params = resolveParams(step.params, stepContext);
+        if (step.routingGroup) {
+            params.routingGroup = step.routingGroup;
+        }
+        const promptInputs = step.prompt ? resolvePromptBindingInputs(step.prompt, stepContext) : {};
         if (step.prompt) {
             params.prompt = renderPrompt(step.prompt, stepContext);
         }
-        const result = await runNodeByKind(step.node, pipelineContext, params, { skipChecks: step.expect !== undefined });
+        const result = await runNodeByKind(step.node, pipelineContext, params, {
+            skipChecks: step.expect !== undefined,
+            contextOverrides: {
+                ...(stepState.value !== undefined ? { resumeStepValue: stepState.value } : {}),
+                persistRunningStepValue: async (value) => {
+                    stepState.value = value;
+                    await options.onStateChange?.(executionState);
+                },
+            },
+        });
         stepState.value = toJsonValue(result.value);
         const stepOutputs = toStepOutputs(result.value);
         if (stepOutputs) {
@@ -249,15 +401,69 @@ export async function runExpandedPhase(phase, pipelineContext, flowParams, flowC
                 runAfterAction(action, pipelineContext, stepContext);
             });
         }
+        const publishedArtifacts = [];
+        const nestedPublishedArtifacts = collectNestedPublishedArtifacts(result.value);
+        const publishableOutputs = (result.outputs ?? []).filter((output) => shouldPublishManifest(output));
+        if (!pipelineContext.dryRun && publishableOutputs.length > 0) {
+            const resolvedPublishableOutputs = [];
+            for (const output of publishableOutputs) {
+                if (!existsSync(output.path)) {
+                    if (!output.required) {
+                        continue;
+                    }
+                    throw new TaskRunnerError(`Cannot publish manifest for missing output ${output.path}.`);
+                }
+                resolvedPublishableOutputs.push(output);
+            }
+            validateDistinctLogicalKeys(pipelineContext.issueKey, phase.id, step.id, resolvedPublishableOutputs);
+            const publishedOutputPaths = resolvedPublishableOutputs.map((output) => output.path);
+            const lineageInputs = collectLineageInputs([result.value], [
+                ...Object.values(step.params ?? {}).flatMap((value) => collectResolvedArtifactPathCandidates(value, stepContext)),
+                ...collectResolvedPromptArtifactPathCandidates(step.prompt, stepContext),
+            ], pipelineContext, publishedOutputPaths);
+            for (const output of resolvedPublishableOutputs) {
+                publishedArtifacts.push(pipelineContext.runtime.artifactRegistry.publish({
+                    scopeKey: pipelineContext.issueKey,
+                    runId: executionState.runId ?? randomUUID(),
+                    publicationRunId: executionState.publicationRunId ?? randomUUID(),
+                    flowId: executionState.flowKind,
+                    phaseId: phase.id,
+                    stepId: step.id,
+                    nodeKind: step.node,
+                    nodeVersion: 1,
+                    kind: output.kind,
+                    payloadPath: output.path,
+                    ...(output.manifest?.logicalKey ? { logicalKey: output.manifest.logicalKey } : {}),
+                    ...(output.manifest?.schemaId ? { schemaId: output.manifest.schemaId } : {}),
+                    ...(output.manifest?.schemaVersion ? { schemaVersion: output.manifest.schemaVersion } : {}),
+                    ...(output.manifest?.payloadFamily ? { payloadFamily: output.manifest.payloadFamily } : {}),
+                    inputs: mergeLineageInputs(lineageInputs, output.manifest?.inputRefs ?? []),
+                    ...producerMetadata(result.value),
+                }));
+            }
+        }
+        const allPublishedArtifacts = mergePublishedArtifacts(publishedArtifacts, nestedPublishedArtifacts);
         const stopFlow = step.stopFlowIf ? evaluateCondition(step.stopFlowIf, stepContext) : false;
         stepState.status = "done";
         stepState.finishedAt = nowIso8601();
         stepState.stopFlow = stopFlow;
+        if (allPublishedArtifacts.length > 0) {
+            stepState.publishedArtifacts = allPublishedArtifacts;
+        }
+        else {
+            delete stepState.publishedArtifacts;
+        }
         await options.onStateChange?.(executionState);
-        steps.push({ id: step.id, status: "done", ...(stepState.outputs ? { outputs: stepState.outputs } : {}) });
+        steps.push({
+            id: step.id,
+            status: "done",
+            ...(stepState.outputs ? { outputs: stepState.outputs } : {}),
+            ...(stepState.publishedArtifacts ? { publishedArtifacts: stepState.publishedArtifacts } : {}),
+        });
         if (stopFlow) {
             executionState.terminated = true;
             executionState.terminationReason = `Stopped by ${phase.id}:${step.id}`;
+            executionState.terminationOutcome = step.stopFlowOutcome ?? "success";
             phaseState.status = "done";
             phaseState.finishedAt = nowIso8601();
             await options.onStateChange?.(executionState);

package/dist/pipeline/declarative-flows.js

@@ -29,6 +29,7 @@ export function loadDeclarativeFlow(flow) {
         kind: spec.kind,
         version: spec.version,
         ...(spec.description !== undefined ? { description: spec.description } : {}),
+        ...(spec.catalogVisibility !== undefined ? { catalogVisibility: spec.catalogVisibility } : {}),
         constants: spec.constants ?? {},
         phases,
         source: ref.source,
@@ -61,3 +62,29 @@ export function resolveNamedDeclarativeFlowRef(fileName, cwd) {
 export function loadNamedDeclarativeFlow(fileName, cwd) {
     return loadDeclarativeFlow(resolveNamedDeclarativeFlowRef(fileName, cwd));
 }
+export function collectFlowRoutingGroups(flow, cwd, visited = new Set()) {
+    if (visited.has(flow.absolutePath)) {
+        return [];
+    }
+    visited.add(flow.absolutePath);
+    const groups = new Set();
+    for (const phase of flow.phases) {
+        for (const step of phase.steps) {
+            if (step.routingGroup) {
+                groups.add(step.routingGroup);
+            }
+            if (step.node !== "flow-run") {
+                continue;
+            }
+            const nestedFlowName = step.params?.fileName;
+            if (!nestedFlowName || !("const" in nestedFlowName) || typeof nestedFlowName.const !== "string") {
+                continue;
+            }
+            const nestedFlow = loadNamedDeclarativeFlow(nestedFlowName.const, cwd);
+            for (const nestedGroup of collectFlowRoutingGroups(nestedFlow, cwd, visited)) {
+                groups.add(nestedGroup);
+            }
+        }
+    }
+    return [...groups];
+}

package/dist/pipeline/execution-routing-config.js

@@ -0,0 +1,15 @@
+export const EXECUTION_ROUTING_GROUPS = [
+    "planning",
+    "design-review",
+    "implementation",
+    "review",
+    "repair-loop",
+    "local-fix-loop",
+];
+export const BUILT_IN_EXECUTION_PRESET_IDS = [
+    "balanced",
+    "quality-first",
+    "cheap-first",
+    "codex-only",
+    "opencode-only",
+];

package/dist/pipeline/flow-catalog.js

@@ -1,18 +1,22 @@
 import path from "node:path";
 import { TaskRunnerError } from "../errors.js";
 import { loadAutoGolangFlow } from "./auto-flow.js";
-import { loadDeclarativeFlow } from "./declarative-flows.js";
+import { collectFlowRoutingGroups, loadDeclarativeFlow } from "./declarative-flows.js";
 import { listBuiltInFlowSpecFiles, listProjectFlowSpecFiles, projectFlowSpecsDir } from "./spec-loader.js";
 export const BUILT_IN_COMMAND_FLOW_IDS = [
     "auto-golang",
     "auto-common",
+    "auto-simple",
     "bug-analyze",
     "bug-fix",
+    "design-review",
     "git-commit",
     "gitlab-diff-review",
     "gitlab-review",
+    "instant-task",
     "mr-description",
     "plan",
+    "plan-revise",
     "task-describe",
     "implement",
     "review",
@@ -24,13 +28,17 @@ export const BUILT_IN_COMMAND_FLOW_IDS = [
 const BUILT_IN_COMMAND_FLOW_FILES = {
     "auto-golang": "auto-golang.json",
     "auto-common": "auto-common.json",
+    "auto-simple": "auto-simple.json",
     "bug-analyze": "bugz/bug-analyze.json",
     "bug-fix": "bugz/bug-fix.json",
+    "design-review": "design-review.json",
     "git-commit": "git-commit.json",
     "gitlab-diff-review": "gitlab/gitlab-diff-review.json",
     "gitlab-review": "gitlab/gitlab-review.json",
+    "instant-task": "instant-task.json",
     "mr-description": "gitlab/mr-description.json",
     plan: "plan.json",
+    "plan-revise": "plan-revise.json",
     "task-describe": "task-describe.json",
     implement: "implement.json",
     review: "review/review.json",
@@ -39,6 +47,9 @@ const BUILT_IN_COMMAND_FLOW_FILES = {
     "run-go-tests-loop": "go/run-go-tests-loop.json",
     "run-go-linter-loop": "go/run-go-linter-loop.json",
 };
+export function builtInCommandFlowFile(flowId) {
+    return BUILT_IN_COMMAND_FLOW_FILES[flowId] ?? null;
+}
 function builtInCommandIdForFile(fileName) {
     for (const [flowId, candidate] of Object.entries(BUILT_IN_COMMAND_FLOW_FILES)) {
         if (candidate === fileName) {
@@ -80,15 +91,16 @@ export function loadInteractiveFlowCatalog(cwd) {
     for (const filePath of listProjectFlowSpecFiles(cwd)) {
         entries.push(loadProjectCatalogEntry(cwd, filePath));
     }
+    const visibleEntries = entries.filter((entry) => entry.flow.catalogVisibility !== "hidden");
     const byId = new Map();
-    for (const entry of entries) {
+    for (const entry of visibleEntries) {
         const duplicate = byId.get(entry.id);
         if (duplicate) {
             throw new TaskRunnerError(`Flow id '${entry.id}' conflicts between ${duplicate.absolutePath} and ${entry.absolutePath}. Rename one of the flow files.`);
         }
         byId.set(entry.id, entry);
     }
-    return entries;
+    return visibleEntries;
 }
 export function findCatalogEntry(flowId, entries) {
     return entries.find((entry) => entry.id === flowId);
@@ -101,3 +113,11 @@ export function toDeclarativeFlowRef(entry) {
         ? { source: "built-in", fileName: entry.fileName }
         : { source: "project-local", filePath: entry.absolutePath };
 }
+export function flowRoutingKey(entry) {
+    return entry.source === "project-local"
+        ? `project-local:${entry.absolutePath}`
+        : `built-in:${entry.id}`;
+}
+export function flowRoutingGroups(entry, cwd) {
+    return collectFlowRoutingGroups(entry.flow, cwd);
+}

package/dist/pipeline/flow-run-resume.js

@@ -0,0 +1,29 @@
+function isFlowExecutionState(value) {
+    if (!value || typeof value !== "object" || Array.isArray(value)) {
+        return false;
+    }
+    const record = value;
+    return (typeof record["flowKind"] === "string"
+        && typeof record["flowVersion"] === "number"
+        && typeof record["terminated"] === "boolean"
+        && Array.isArray(record["phases"]));
+}
+function isPublishedArtifactRecord(value) {
+    if (!value || typeof value !== "object" || Array.isArray(value)) {
+        return false;
+    }
+    const record = value;
+    return typeof record["artifact_id"] === "string" && typeof record["payload_path"] === "string";
+}
+export function isFlowRunResumeEnvelope(value) {
+    if (!value || typeof value !== "object" || Array.isArray(value)) {
+        return false;
+    }
+    const record = value;
+    return (record["resumeKind"] === "flow-run"
+        && typeof record["flowKind"] === "string"
+        && typeof record["flowVersion"] === "number"
+        && isFlowExecutionState(record["executionState"])
+        && Array.isArray(record["publishedArtifacts"])
+        && record["publishedArtifacts"].every((artifact) => isPublishedArtifactRecord(artifact)));
+}