@tea-agent/loop-agent 0.1.0

package/dist/task/read-model.js

@@ -0,0 +1,149 @@
+import { access } from "node:fs/promises";
+import path from "node:path";
+import { queryCursorRuns } from "../records/one-shot-runs.js";
+import { defaultHybridDagOutputPath } from "../workflows/dag/init-hybrid.js";
+import { listAllDagRunEntries, readDagRunSpec } from "../workflows/dag/lifecycle.js";
+import { getTaskDir, getTaskPaths, getTaskStatus } from "./runtime.js";
+async function exists(filePath) {
+    try {
+        await access(filePath);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+async function listRelatedDagRuns(repoRoot, taskId) {
+    const entries = await listAllDagRunEntries(repoRoot);
+    const related = [];
+    for (const entry of entries) {
+        if (entry.runId.includes(taskId)) {
+            related.push(entry);
+            continue;
+        }
+        const spec = await readDagRunSpec(entry.runDir).catch(() => null);
+        if (spec && JSON.stringify(spec).includes(taskId)) {
+            related.push(entry);
+        }
+    }
+    return related;
+}
+function defaultDagDraftPath(taskId) {
+    return defaultHybridDagOutputPath(taskId);
+}
+function closeoutPath(repoRoot, taskId) {
+    return path.join(repoRoot, "docs", "progress", `${taskId}.md`);
+}
+function deriveNextAction(input) {
+    if (!input.sourceReady) {
+        return {
+            command: `npm run dev -- instructions source --task ${input.taskId} --json`,
+            reason: "source materials are not ready",
+        };
+    }
+    if (!input.dagDraftExists && !input.latestDagRun) {
+        return {
+            command: `npm run dev -- dag run-task ${input.taskId} --profile auto --strict-models --output ${input.dagDraftPath}`,
+            reason: "source ready; DAG draft/run evidence not found",
+        };
+    }
+    if (input.dagDraftExists && !input.latestDagRun) {
+        return {
+            command: `npm run dev -- dag validate --dag ${input.dagDraftPath} --strict-models --strict-governance`,
+            reason: "DAG draft exists and needs validation/execution",
+        };
+    }
+    if (input.latestDagRun && input.latestDagRun.lifecycle !== "completed") {
+        return {
+            command: `npm run dev -- dag status --run-id ${input.latestDagRun.runId}`,
+            reason: "DAG run exists but is not completed",
+        };
+    }
+    if (input.latestDagRun && input.promotionRequired && !input.promotionReady) {
+        return {
+            command: `npm run dev -- promote-run ${input.taskId} --run-id ${input.latestDagRun.runId}`,
+            reason: "completed run evidence needs promotion into task artifacts",
+        };
+    }
+    if (!input.closeoutExists) {
+        return {
+            command: `npm run dev -- closeout task ${input.taskId}`,
+            reason: "promoted task evidence needs closeout",
+        };
+    }
+    return {
+        command: `npm run dev -- dag report --task ${input.taskId}`,
+        reason: "task has source, run evidence, promotion, and closeout records",
+    };
+}
+export async function buildTaskReadModel(repoRoot, taskId) {
+    const taskDir = getTaskDir(repoRoot, taskId);
+    const paths = getTaskPaths(repoRoot, taskId);
+    const legacyState = await getTaskStatus(repoRoot, taskId);
+    const requirementPath = path.join(paths.sourceDir, "需求.md");
+    const constraintPath = path.join(paths.sourceDir, "执行约束.md");
+    const missing = [];
+    if (!(await exists(requirementPath)))
+        missing.push(requirementPath);
+    const sourceReady = missing.length === 0;
+    const dagDraftPath = defaultDagDraftPath(taskId);
+    const dagDraftExists = await exists(dagDraftPath);
+    const dagRuns = await listRelatedDagRuns(repoRoot, taskId);
+    const latestDagRun = dagRuns.at(-1) ?? null;
+    const oneShotRuns = await queryCursorRuns(repoRoot, { taskId });
+    const hasCompletedRun = latestDagRun?.lifecycle === "completed" ||
+        oneShotRuns.some((run) => run.status === "completed");
+    const promotionReady = legacyState.artifacts.modifyLog && legacyState.artifacts.verifyResult;
+    const closeout = closeoutPath(repoRoot, taskId);
+    const closeoutExists = await exists(closeout);
+    const nextAction = deriveNextAction({
+        taskId,
+        sourceReady,
+        dagDraftPath,
+        dagDraftExists,
+        latestDagRun,
+        promotionRequired: hasCompletedRun,
+        promotionReady,
+        closeoutExists,
+    });
+    return {
+        taskId,
+        taskDir,
+        sourceReadiness: {
+            ready: sourceReady,
+            missing,
+            requirementPath,
+            constraintPath,
+        },
+        dagDraft: {
+            path: dagDraftPath,
+            exists: dagDraftExists,
+        },
+        latestDagRun,
+        promotion: {
+            required: hasCompletedRun,
+            ready: promotionReady,
+        },
+        closeout: {
+            path: closeout,
+            exists: closeoutExists,
+        },
+        loopState: {
+            path: path.join(taskDir, "loop-state.json"),
+            exists: await exists(path.join(taskDir, "loop-state.json")),
+        },
+        legacyWorkflowState: {
+            status: legacyState.status,
+            currentStep: legacyState.currentStep,
+            completedSteps: legacyState.completedSteps,
+        },
+        runRefs: {
+            oneShotRuns: oneShotRuns.map((run) => ({
+                status: run.status,
+                logPath: run.logPath,
+            })),
+            dagRuns: dagRuns.map((run) => run.runId),
+        },
+        nextAction,
+    };
+}