@tea-agent/loop-agent 0.8.0 → 0.10.0-alpha.0

package/dist/worker/feature/next-action.js

@@ -0,0 +1,74 @@
+export function projectNextAction(input, status) {
+    const featureArgs = `--feature-dir ${quote(input.featureDir)} --repo ${quote(input.repoRoot)}`;
+    const resolvedFailures = new Set(input.resolvedFailureTaskIds ?? []);
+    if (input.projectionWarnings.length > 0 || !input.validationOk) {
+        return {
+            kind: "repair_projection",
+            label: "修复 Feature Packet 或运行事实后重新审阅",
+            ...(!input.validationOk
+                ? { command: `agent-worker task validate-feature ${quote(input.featureDir)}` }
+                : {}),
+        };
+    }
+    const actionCard = input.actionCards?.[0];
+    if (actionCard) {
+        return { kind: actionCard.action, label: actionCard.label, ...(actionCard.command ? { command: actionCard.command } : {}) };
+    }
+    const highRisk = input.tasks.find((task) => ["RiskyChange", "ContractMismatch", "SpecUnclear", "NeedsHuman"].includes(task.failureCategory ?? "") && !resolvedFailures.has(task.taskId));
+    if (highRisk) {
+        return {
+            kind: "resolve_high_risk_gate",
+            label: `人工审查 ${highRisk.taskId} 的 ${highRisk.failureCategory} Gate`,
+        };
+    }
+    const pendingFollowUp = input.pendingFollowUps?.[0];
+    if (pendingFollowUp) {
+        return {
+            kind: "approve_followup",
+            label: `批准 ${pendingFollowUp.followUpId}`,
+            command: `agent-worker feature approve-followup --feature-dir ${quote(input.featureDir)} --followup-id ${quote(pendingFollowUp.followUpId)} --repo ${quote(input.repoRoot)} --owner <owner>`,
+        };
+    }
+    const failed = input.tasks.find((task) => task.status === "Failed" && !resolvedFailures.has(task.taskId));
+    if (failed) {
+        if (failed.failureCategory === "EnvFailure") {
+            return {
+                kind: "retry_task",
+                label: `重试环境失败任务 ${failed.taskId}`,
+                command: `agent-worker task retry ${quote(failed.taskId)} --repo ${quote(input.repoRoot)}`,
+            };
+        }
+        return {
+            kind: "handle_failure",
+            label: `根据失败证据处理 ${failed.taskId}；ProductBug 可生成并人工批准 Follow-up`,
+        };
+    }
+    const blocked = input.tasks.find((task) => ["Blocked", "HumanReview", "Abandoned"].includes(task.status ?? ""));
+    if (blocked) {
+        return {
+            kind: "resolve_human_gate",
+            label: `处理 ${blocked.taskId} 的人工 Gate 或阻塞原因`,
+        };
+    }
+    if (status === "ready") {
+        return {
+            kind: "run_feature",
+            label: "执行当前 Ready tasks",
+            command: `agent-worker batch run-ready ${featureArgs}`,
+        };
+    }
+    if (status === "awaiting_qa") {
+        return { kind: "complete_qa", label: "补齐 QA verdict 与 required AC 证据" };
+    }
+    if (status === "deliverable") {
+        return {
+            kind: "prepare_closeout",
+            label: "预览 Feature Closeout gates",
+            command: `agent-worker feature closeout ${featureArgs}`,
+        };
+    }
+    return null;
+}
+function quote(value) {
+    return JSON.stringify(value);
+}

package/dist/worker/feature/reducer.js

@@ -0,0 +1,133 @@
+import { projectNextAction } from "./next-action.js";
+const STATUS_LABELS = {
+    draft: "待准备",
+    ready: "可执行",
+    running: "执行中",
+    needs_action: "需处理",
+    awaiting_qa: "待验收",
+    deliverable: "可交付",
+    closed: "已关闭",
+};
+export function reduceFeature(input) {
+    const status = deriveStatus(input);
+    const readyTasks = input.tasks.filter((task) => isReady(task.taskId, input));
+    const blockingItems = [];
+    const resolvedFailures = new Set(input.resolvedFailureTaskIds ?? []);
+    for (const error of input.validationErrors) {
+        blockingItems.push({ type: "validation_error", message: error, evidence: [] });
+    }
+    for (const warning of input.projectionWarnings) {
+        blockingItems.push({ type: "projection_warning", message: warning, evidence: [] });
+    }
+    for (const followUp of input.pendingFollowUps ?? []) {
+        blockingItems.push({
+            type: "pending_follow_up",
+            taskId: followUp.parentTaskId,
+            followUpId: followUp.followUpId,
+            message: `${followUp.followUpId} is waiting for approval`,
+            evidence: [followUp.draftPath],
+        });
+    }
+    for (const card of input.actionCards ?? []) {
+        blockingItems.push({ type: "follow_up_action", taskId: card.parentTaskId, followUpId: card.followUpId, message: card.label, evidence: [card.draftPath] });
+    }
+    for (const task of input.tasks.filter((item) => ["Failed", "Blocked", "HumanReview", "Abandoned"].includes(item.status ?? "") &&
+        !(item.status === "Failed" && resolvedFailures.has(item.taskId)))) {
+        blockingItems.push({
+            type: task.status === "Failed"
+                ? "failed_task"
+                : task.status === "HumanReview"
+                    ? "human_gate"
+                    : task.status === "Abandoned"
+                        ? "abandoned_task"
+                        : "blocked_task",
+            taskId: task.taskId,
+            ...(task.failureCategory ? { failureCategory: task.failureCategory } : {}),
+            message: `${task.taskId} is ${task.status}`,
+            evidence: task.failureEvidence ?? [],
+        });
+    }
+    const required = input.acceptance.filter((item) => item.required);
+    return {
+        schemaVersion: 1,
+        featureId: input.featureId,
+        status,
+        statusLabel: STATUS_LABELS[status],
+        summary: {
+            tasksTotal: input.tasks.length,
+            tasksSucceeded: input.tasks.filter((task) => task.status === "Done").length,
+            tasksFailed: input.tasks.filter((task) => task.status === "Failed").length,
+            tasksReady: readyTasks.length,
+            tasksBlocked: input.tasks.filter((task) => task.status === "Blocked").length,
+            requiredAcTotal: required.length,
+            requiredAcCovered: required.filter((item) => item.status === "covered" || item.status === "waived").length,
+        },
+        riskSummary: {
+            high: (input.delivery?.riskSummary?.high ?? 0) + input.tasks.filter((task) => ["RiskyChange", "ContractMismatch", "SpecUnclear", "NeedsHuman"].includes(task.failureCategory ?? "")).length,
+            medium: (input.delivery?.riskSummary?.medium ?? 0) + input.tasks.filter((task) => task.status === "Failed" && !["RiskyChange", "ContractMismatch", "SpecUnclear", "NeedsHuman"].includes(task.failureCategory ?? "")).length,
+            low: (input.delivery?.riskSummary?.low ?? 0) + input.tasks.filter((task) => task.status === "Blocked").length,
+        },
+        blockingItems,
+        followUps: {
+            pending: input.pendingFollowUps ?? [],
+            actionCards: input.actionCards ?? [],
+            resolvedFailureTaskIds: input.resolvedFailureTaskIds ?? [],
+        },
+        tasks: input.tasks.map((task) => ({
+            taskId: task.taskId,
+            type: task.type,
+            status: task.status ?? (isReady(task.taskId, input) ? "Ready" : "Draft"),
+        })),
+        acceptanceCoverage: input.acceptance,
+        nextAction: projectNextAction(input, status),
+        alternativeActions: [],
+        evidence: {
+            morningReport: input.morningReport ?? null,
+            observeSnapshot: input.observeSnapshot ?? null,
+            delivery: input.delivery?.path ?? null,
+            closeout: input.closeout?.path ?? null,
+        },
+        projectionWarnings: [...input.projectionWarnings],
+    };
+}
+function deriveStatus(input) {
+    if (!input.validationOk)
+        return "draft";
+    if (input.projectionWarnings.length > 0)
+        return "needs_action";
+    if ((input.pendingFollowUps?.length ?? 0) > 0)
+        return "needs_action";
+    if ((input.actionCards?.length ?? 0) > 0)
+        return "needs_action";
+    const requiredComplete = input.acceptance
+        .filter((item) => item.required)
+        .every((item) => item.status === "covered" || item.status === "waived");
+    const resolvedFailures = new Set(input.resolvedFailureTaskIds ?? []);
+    const allTasksDone = input.tasks.length > 0 && input.tasks.every((task) => task.status === "Done" || (task.status === "Failed" && resolvedFailures.has(task.taskId)));
+    if (input.closeout?.applied &&
+        input.closeout.valid &&
+        input.delivery?.valid &&
+        requiredComplete &&
+        allTasksDone)
+        return "closed";
+    if (input.tasks.some((task) => ["Failed", "Blocked", "HumanReview", "Abandoned"].includes(task.status ?? "") &&
+        !(task.status === "Failed" && (input.resolvedFailureTaskIds ?? []).includes(task.taskId)))) {
+        return "needs_action";
+    }
+    if (input.tasks.some((task) => ["Queued", "Running", "AgentCompleted", "VerificationRunning"].includes(task.status ?? "")))
+        return "running";
+    if (input.tasks.some((task) => isReady(task.taskId, input)))
+        return "ready";
+    if (allTasksDone && requiredComplete && input.delivery?.valid) {
+        return "deliverable";
+    }
+    if (allTasksDone)
+        return "awaiting_qa";
+    return "draft";
+}
+function isReady(taskId, input) {
+    const task = input.tasks.find((item) => item.taskId === taskId);
+    if (!task || task.status)
+        return task?.status === "Ready";
+    return task.dependsOn.every((dependencyId) => input.tasks.find((item) => item.taskId === dependencyId)?.status === "Done");
+}