@tea-agent/loop-agent 0.1.0 → 0.2.0

package/dist/workflows/loop/actions/workflow-action.js

@@ -0,0 +1,255 @@
+import { mkdir, readFile, writeFile } from "node:fs/promises";
+import path from "node:path";
+import { compileWorkflowToDag, defaultCompileManifestPath, } from "../../dynamic/compile.js";
+import { buildWorkflowSpecForProfile } from "../../dynamic/profiles.js";
+import { parseWorkflowSpec } from "../../dynamic/validate.js";
+import { resumeDagRun, runDag } from "../../dag/runner.js";
+import { assertValidDagSpec } from "../../dag/validate.js";
+import { assertDagRunTransferTargetAvailable, getDagRunDir, locateDagRun, readHumanEscalation, requirePausedDagRun, transferDagRunDir, writeDagRunState, writeHumanApprovalArtifact, } from "../../dag/lifecycle.js";
+import { getTaskPaths } from "../../../task/runtime.js";
+import { appendLoopRound } from "../rounds.js";
+import { rewriteLoopContext } from "../context.js";
+import { readLoopRounds } from "../rounds.js";
+import { drainLoopSignals, pendingLoopSignals } from "../signals.js";
+import { dagRunIdFromApprovalMessage, dagRunIdFromRef, relativeRef, summarizeWorkflowReport, workflowFailureCategory, } from "./shared.js";
+export async function runLoopWorkflowAction(repoRoot, taskId, options = {}) {
+    const mode = options.mode ?? "review";
+    const cwd = options.cwd ? path.resolve(repoRoot, options.cwd) : repoRoot;
+    const rounds = await readLoopRounds(repoRoot, taskId);
+    const round = rounds.length + 1;
+    const taskPaths = getTaskPaths(repoRoot, taskId);
+    const workflowRoot = path.join(taskPaths.taskDir, "workflows");
+    const plannedDir = path.join(workflowRoot, "planned");
+    const compiledDir = path.join(workflowRoot, "compiled");
+    const reportsDir = path.join(workflowRoot, "reports");
+    await mkdir(plannedDir, { recursive: true });
+    await mkdir(compiledDir, { recursive: true });
+    await mkdir(reportsDir, { recursive: true });
+    const profile = options.profile ?? "pr-review";
+    const workflowPath = options.workflowPath
+        ? path.resolve(repoRoot, options.workflowPath)
+        : path.join(plannedDir, `${profile}.workflow.json`);
+    const workflow = options.workflowPath
+        ? parseWorkflowSpec(JSON.parse(await readFile(workflowPath, "utf-8")))
+        : buildWorkflowSpecForProfile({
+            profile,
+            taskId,
+            base: options.base,
+            head: options.head,
+            changedFiles: options.changedFiles,
+        });
+    if (!options.workflowPath) {
+        await writeFile(workflowPath, `${JSON.stringify(workflow, null, 2)}\n`, "utf-8");
+    }
+    const compiledDagPath = path.join(compiledDir, `${workflow.meta.name}.dag.json`);
+    const compileManifestPath = defaultCompileManifestPath(compiledDagPath);
+    const compiled = compileWorkflowToDag(workflow, { sourcePath: workflowPath });
+    assertValidDagSpec(compiled.dag, { strictGovernance: true });
+    await writeFile(compiledDagPath, `${JSON.stringify(compiled.dag, null, 2)}\n`, "utf-8");
+    await writeFile(compileManifestPath, `${JSON.stringify(compiled.manifest, null, 2)}\n`, "utf-8");
+    let runId = "";
+    let runStatus = "not-run";
+    let runRef = "";
+    let failureCategory = "";
+    let decision = "continue";
+    let result = "workflow planned, compiled, and strict-governance validated";
+    let verification = "workflow compiled DAG validated with strict governance";
+    let expectedNextVerification = "inspect workflow DAG/report refs before executing or closing out";
+    const reportPath = path.join(reportsDir, `${workflow.meta.name}.workflow-report.md`);
+    if (mode === "execute") {
+        const summary = await runDag(compiled.dag, {
+            cwd,
+            runId: options.runId,
+            maxConcurrent: options.maxConcurrent,
+        });
+        runId = summary.runId;
+        runStatus = summary.status;
+        runRef = relativeRef(repoRoot, summary.runDir);
+        failureCategory = workflowFailureCategory(summary.nodes);
+        decision = runStatus === "paused" ? "pause" : "continue";
+        expectedNextVerification =
+            decision === "pause"
+                ? "approve or reject paused workflow DAG run, then resume or replan"
+                : "review workflow report and run any required shell verification";
+        const report = summarizeWorkflowReport(summary.nodes[workflow.final.from]?.stdout);
+        result = report.result;
+        verification = `workflow run status=${runStatus}; ${report.verification}`;
+        await writeFile(reportPath, report.markdown, "utf-8");
+    }
+    else {
+        await writeFile(reportPath, "# Workflow Report\n\nWorkflow was compiled in review mode and not executed.\n", "utf-8");
+    }
+    const record = {
+        schemaVersion: 1,
+        taskId,
+        round,
+        action: "workflow",
+        mode,
+        profile: workflow.meta.name,
+        ok: mode === "review" || runStatus === "finished",
+        workflowRef: relativeRef(repoRoot, workflowPath),
+        compiledDagRef: relativeRef(repoRoot, compiledDagPath),
+        compileManifestRef: relativeRef(repoRoot, compileManifestPath),
+        runId,
+        runStatus,
+        runRef,
+        reportRef: relativeRef(repoRoot, reportPath),
+        result,
+        verification,
+        failureCategory,
+        expectedNextVerification,
+        recordedAt: new Date().toISOString(),
+    };
+    await appendLoopRound(repoRoot, taskId, {
+        action: "workflow",
+        refs: [
+            record.workflowRef,
+            record.compiledDagRef,
+            record.compileManifestRef,
+            record.runRef,
+            record.reportRef,
+        ].filter(Boolean),
+        result,
+        verification,
+        lesson: mode === "review"
+            ? "Workflow spec is planned and compiled; inspect workflow refs before execution."
+            : "Workflow run facts recorded by ref; keep detailed node outputs in DAG artifacts.",
+        next: expectedNextVerification,
+        decision,
+        failureCategory,
+        completedCriteria: ["workflow round action executed"],
+    });
+    await rewriteLoopContext(repoRoot, taskId);
+    return record;
+}
+async function findPausedWorkflowGateRunId(input) {
+    const candidates = new Set();
+    const fromMessage = dagRunIdFromApprovalMessage(input.signal.message);
+    if (fromMessage)
+        candidates.add(fromMessage);
+    for (const ref of input.signal.refs) {
+        const fromRef = dagRunIdFromRef(ref);
+        if (fromRef)
+            candidates.add(fromRef);
+    }
+    const rounds = await readLoopRounds(input.repoRoot, input.taskId);
+    for (const round of [...rounds].reverse()) {
+        if (round.action !== "workflow")
+            continue;
+        for (const ref of round.refs) {
+            const fromRef = dagRunIdFromRef(ref);
+            if (fromRef)
+                candidates.add(fromRef);
+        }
+    }
+    for (const candidate of candidates) {
+        const located = await locateDagRun(input.repoRoot, candidate);
+        if (located?.lifecycle === "paused")
+            return candidate;
+    }
+    return undefined;
+}
+async function approvePausedDagRunFromSignal(input) {
+    const { runDir, state } = await requirePausedDagRun(input.repoRoot, input.runId);
+    const nodeId = state.pausedByNodeId;
+    const node = state.nodes[nodeId];
+    if (!node) {
+        throw new Error(`paused node ${nodeId} not found in run state`);
+    }
+    const escalation = await readHumanEscalation(runDir, nodeId);
+    const options = escalation.humanEscalation.options.map((entry) => entry.id);
+    const selectedOption = escalation.humanEscalation.recommendedOption &&
+        options.includes(escalation.humanEscalation.recommendedOption)
+        ? escalation.humanEscalation.recommendedOption
+        : options[0];
+    if (!selectedOption) {
+        throw new Error(`missing human escalation options for node ${nodeId}`);
+    }
+    const activeRunDir = getDagRunDir(input.repoRoot, "active", state.runId);
+    await assertDagRunTransferTargetAvailable(activeRunDir);
+    const approvedAt = new Date().toISOString();
+    const artifact = {
+        schemaVersion: 1,
+        runId: state.runId,
+        nodeId,
+        decision: "approved",
+        selectedOption,
+        notes: `Approved by loop approval signal ${input.signal.id}: ${input.signal.message}`,
+        approvedAt,
+        escalationArtifactPath: node.escalationArtifactPath,
+    };
+    const approvalPath = await writeHumanApprovalArtifact({
+        runDir,
+        nodeId,
+        artifact,
+    });
+    node.pauseReason = undefined;
+    node.humanApprovalArtifactPath = approvalPath;
+    state.status = "running";
+    state.humanDecisionNodeId = nodeId;
+    delete state.pausedAt;
+    delete state.pausedByNodeId;
+    delete state.pauseReason;
+    await writeDagRunState(runDir, state);
+    await transferDagRunDir(runDir, activeRunDir);
+    return { selectedOption };
+}
+export async function runLoopWorkflowGateSignalAction(repoRoot, taskId, signals = []) {
+    const approvalSignal = pendingLoopSignals(signals).find((signal) => signal.type === "approval");
+    if (!approvalSignal)
+        return undefined;
+    const runId = await findPausedWorkflowGateRunId({
+        repoRoot,
+        taskId,
+        signal: approvalSignal,
+    });
+    if (!runId)
+        return undefined;
+    const rounds = await readLoopRounds(repoRoot, taskId);
+    const round = rounds.length + 1;
+    const approval = await approvePausedDagRunFromSignal({
+        repoRoot,
+        runId,
+        signal: approvalSignal,
+    });
+    const summary = await resumeDagRun({ cwd: repoRoot, runId });
+    const runRef = relativeRef(repoRoot, summary.runDir);
+    const failureCategory = workflowFailureCategory(summary.nodes);
+    const decision = summary.status === "paused" ? "pause" : "continue";
+    const expectedNextVerification = decision === "pause"
+        ? "approve or reject paused workflow DAG run, then resume or replan"
+        : "review resumed workflow report and run any required shell verification";
+    const result = `approval signal satisfied workflow human gate for DAG run ${runId}`;
+    const verification = `workflow gate approved with option=${approval.selectedOption}; resumed status=${summary.status}`;
+    const record = {
+        schemaVersion: 1,
+        taskId,
+        round,
+        action: "workflow-gate-signal",
+        ok: summary.status === "finished",
+        signalId: approvalSignal.id,
+        runId,
+        selectedOption: approval.selectedOption,
+        runStatus: summary.status,
+        runRef,
+        result,
+        verification,
+        failureCategory,
+        expectedNextVerification,
+        recordedAt: new Date().toISOString(),
+    };
+    await appendLoopRound(repoRoot, taskId, {
+        action: "workflow-gate-signal",
+        refs: [...approvalSignal.refs, runRef].filter(Boolean),
+        result,
+        verification,
+        lesson: "Loop approval signal was converted into the existing DAG approval/resume lifecycle.",
+        next: expectedNextVerification,
+        decision,
+        failureCategory,
+        completedCriteria: ["workflow human gate approval signal consumed"],
+    });
+    await drainLoopSignals(repoRoot, taskId, [approvalSignal.id]);
+    await rewriteLoopContext(repoRoot, taskId);
+    return record;
+}