@tea-agent/loop-agent 0.17.1 → 0.18.0

package/dist/worker/console/interview/grill-me.js

@@ -0,0 +1,253 @@
+/**
+ * Deterministic grill-me Requirement Interview engine (design §7.8).
+ * One open question at a time; Draft updates from answers; integrity
+ * assessment when required fields are present.
+ */
+import { consoleWorkflowKindPromptList, normalizeConsoleWorkflowKind, } from "../workflow-kinds.js";
+const GAP_ORDER = [
+    "objective",
+    "scope",
+    "nonGoals",
+    "acceptanceCriteria",
+    "taskKind",
+    "allowedPaths",
+    "forbiddenPaths",
+    "verifyCommands",
+];
+function hasText(value) {
+    return typeof value === "string" && value.trim().length > 0;
+}
+function hasItems(value) {
+    return Array.isArray(value) && value.length > 0;
+}
+export function listDraftGaps(draft) {
+    const gaps = [];
+    const req = draft.requirement ?? {};
+    if (!hasText(req.objective))
+        gaps.push("objective");
+    if (!hasItems(req.scope))
+        gaps.push("scope");
+    if (!hasItems(req.nonGoals))
+        gaps.push("nonGoals");
+    if (!hasItems(req.acceptanceCriteria))
+        gaps.push("acceptanceCriteria");
+    if (!hasText(draft.taskKind))
+        gaps.push("taskKind");
+    if (!hasItems(draft.constraints?.allowedPaths))
+        gaps.push("allowedPaths");
+    if (!hasItems(draft.constraints?.forbiddenPaths))
+        gaps.push("forbiddenPaths");
+    if (!hasItems(draft.verification?.commands))
+        gaps.push("verifyCommands");
+    return gaps;
+}
+export function isDraftStructurallyComplete(draft) {
+    return listDraftGaps(draft).length === 0;
+}
+export function buildQuestionForGap(gapId, draft) {
+    const taskId = draft.taskId;
+    const questions = {
+        objective: {
+            id: `q-${gapId}`,
+            gapId,
+            text: `任务 ${taskId} 的核心目标（objective）是什么？请用一句话说明要交付什么。`,
+            recommendation: `实现并验证 ${taskId} 的明确、可验收交付物`,
+            affectsFields: ["requirement.objective"],
+            risk: "high",
+        },
+        scope: {
+            id: `q-${gapId}`,
+            gapId,
+            text: "本轮允许改动的范围（scope）是哪些路径/模块？用逗号或换行列出。",
+            recommendation: "src/worker/console/**",
+            affectsFields: ["requirement.scope"],
+            risk: "high",
+        },
+        nonGoals: {
+            id: `q-${gapId}`,
+            gapId,
+            text: "明确非目标（non-goals）是什么？本轮刻意不做哪些事？",
+            recommendation: "Phase 4 General Operator Chat；合并 Console/Observe",
+            affectsFields: ["requirement.nonGoals"],
+            risk: "medium",
+        },
+        acceptanceCriteria: {
+            id: `q-${gapId}`,
+            gapId,
+            text: "验收标准有哪些？可用分号或换行列出（将编号为 AC-1…）。",
+            recommendation: "Happy Path 可走通 Interview→validate→apply；无 Cancel；无直接改代码 CTA",
+            affectsFields: ["requirement.acceptanceCriteria"],
+            risk: "high",
+        },
+        taskKind: {
+            id: `q-${gapId}`,
+            gapId,
+            text: `流程类型（taskKind）应设为？(${consoleWorkflowKindPromptList()})`,
+            recommendation: "standard",
+            affectsFields: ["taskKind"],
+            risk: "medium",
+        },
+        allowedPaths: {
+            id: `q-${gapId}`,
+            gapId,
+            text: "结构化 allowedPaths（写入白名单）？逗号/换行分隔 glob。",
+            recommendation: "src/worker/console/**, test/worker/console/**",
+            affectsFields: ["constraints.allowedPaths"],
+            risk: "high",
+        },
+        forbiddenPaths: {
+            id: `q-${gapId}`,
+            gapId,
+            text: "forbiddenPaths（禁止写入）？逗号/换行分隔。",
+            recommendation: "src/cli/**, bin/**, package.json",
+            affectsFields: ["constraints.forbiddenPaths"],
+            risk: "high",
+        },
+        verifyCommands: {
+            id: `q-${gapId}`,
+            gapId,
+            text: "验证命令（verifyCommands）？可给一条或多条 shell（换行分隔）。",
+            recommendation: "npx vitest run test/worker/console",
+            affectsFields: ["verification.commands"],
+            risk: "medium",
+        },
+    };
+    return questions[gapId];
+}
+export function nextGrillMeQuestion(draft) {
+    const gaps = listDraftGaps(draft);
+    for (const gapId of GAP_ORDER) {
+        if (gaps.includes(gapId))
+            return buildQuestionForGap(gapId, draft);
+    }
+    return undefined;
+}
+function splitList(text) {
+    return text
+        .split(/[\n,;，；]+/)
+        .map((s) => s.trim())
+        .filter(Boolean);
+}
+function resolveAnswerText(response, recommendation, text) {
+    if (response === "accept-recommendation")
+        return recommendation;
+    if (response === "defer")
+        return text?.trim() || recommendation;
+    return (text ?? "").trim() || recommendation;
+}
+/**
+ * Apply one grill-me answer onto Draft. Returns updated draft (immutable merge).
+ */
+export function applyGrillMeAnswer(draft, question, answer) {
+    const value = resolveAnswerText(answer.response, question.recommendation, answer.text);
+    const next = {
+        ...draft,
+        requirement: { ...draft.requirement },
+        constraints: {
+            invariants: draft.constraints?.invariants ?? [],
+            allowedPaths: draft.constraints?.allowedPaths ?? [],
+            forbiddenPaths: draft.constraints?.forbiddenPaths ?? [],
+            ...draft.constraints,
+        },
+        verification: {
+            commands: draft.verification?.commands ?? [],
+            ...draft.verification,
+        },
+    };
+    switch (question.gapId) {
+        case "objective":
+            next.requirement = { ...next.requirement, objective: value };
+            break;
+        case "scope":
+            next.requirement = { ...next.requirement, scope: splitList(value) };
+            break;
+        case "nonGoals":
+            next.requirement = { ...next.requirement, nonGoals: splitList(value) };
+            break;
+        case "acceptanceCriteria":
+            next.requirement = {
+                ...next.requirement,
+                acceptanceCriteria: splitList(value).map((text, i) => ({
+                    id: `AC-${i + 1}`,
+                    text,
+                })),
+            };
+            break;
+        case "taskKind":
+            next.taskKind = normalizeConsoleWorkflowKind(value, "standard");
+            break;
+        case "allowedPaths":
+            next.constraints = {
+                ...next.constraints,
+                allowedPaths: splitList(value),
+            };
+            break;
+        case "forbiddenPaths":
+            next.constraints = {
+                ...next.constraints,
+                forbiddenPaths: splitList(value),
+            };
+            break;
+        case "verifyCommands":
+            next.verification = {
+                ...next.verification,
+                commands: splitList(value).map((command, i) => ({
+                    label: `verify-${i + 1}`,
+                    command,
+                    timeoutMs: 120_000,
+                })),
+            };
+            break;
+    }
+    if (answer.response === "defer" && question.risk !== "high") {
+        const assumptions = Array.isArray(draft.assumptions)
+            ? [...draft.assumptions]
+            : [];
+        assumptions.push({
+            questionId: question.id,
+            gapId: question.gapId,
+            assumed: value,
+            at: new Date().toISOString(),
+        });
+        next.assumptions = assumptions;
+    }
+    return next;
+}
+export function emptyDraft(taskId, title, options) {
+    const taskKind = options?.taskKind?.trim()
+        ? normalizeConsoleWorkflowKind(options.taskKind, "standard")
+        : undefined;
+    return {
+        schemaVersion: 1,
+        taskId,
+        title: title?.trim() || taskId,
+        taskKind,
+        requirement: {},
+        constraints: {
+            invariants: [],
+            allowedPaths: [],
+            forbiddenPaths: [],
+        },
+        verification: {
+            commands: [],
+        },
+        openQuestions: [],
+        assumptions: [],
+    };
+}
+export function draftSummary(draft) {
+    return {
+        taskId: draft.taskId,
+        title: draft.title,
+        taskKind: draft.taskKind ?? null,
+        objective: draft.requirement?.objective ?? null,
+        scope: draft.requirement?.scope ?? [],
+        nonGoals: draft.requirement?.nonGoals ?? [],
+        acceptanceCriteria: draft.requirement?.acceptanceCriteria ?? [],
+        allowedPaths: draft.constraints?.allowedPaths ?? [],
+        forbiddenPaths: draft.constraints?.forbiddenPaths ?? [],
+        verifyCommands: draft.verification?.commands ?? [],
+        gaps: listDraftGaps(draft),
+        structurallyComplete: isDraftStructurallyComplete(draft),
+    };
+}

package/dist/worker/console/operation-runner.js

@@ -128,7 +128,8 @@ async function finalizeFromWorkerResult(operationId, result, deps) {
         errorMessage: ok
             ? undefined
             : (envelope?.error?.message ??
-                `command failed with exit ${result.exitCode}`),
+                (previewStderr.trim() ||
+                    `command failed with exit ${result.exitCode}`)),
     });
     stateEvent(deps.events, updated, state);
     deps.events.append(operationId, {