sdd-flow-kit 1.3.6 → 1.3.11

package/dist/core/prdRemediate.js

@@ -0,0 +1,300 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MAX_REMEDIATE_ROUNDS = exports.MAX_PRD_FIX_RETRIES = void 0;
+exports.collectRemediableItems = collectRemediableItems;
+exports.buildRemediatePrompt = buildRemediatePrompt;
+exports.writeRemediateBrief = writeRemediateBrief;
+exports.escalateFailuresToHumanConfirm = escalateFailuresToHumanConfirm;
+exports.runPrdRemediateLoop = runPrdRemediateLoop;
+const path_1 = __importDefault(require("path"));
+const fs_1 = require("./fs");
+const agentRemediateInvoke_1 = require("./agentRemediateInvoke");
+const prdRemediateState_1 = require("./prdRemediateState");
+/** 每项 PRD 原子最多自动修复次数 */
+exports.MAX_PRD_FIX_RETRIES = 3;
+/** 防止单项轮换时无限循环的安全上限（全局 agent 调用轮数） */
+exports.MAX_REMEDIATE_ROUNDS = 50;
+/** 需要从代码/测试层修复的语义 diff 条目 */
+function collectRemediableItems(semantic) {
+    if (!semantic)
+        return [];
+    return semantic.items.filter((i) => {
+        if (i.reportVerdict === "待人工确认")
+            return false;
+        return (i.status === "missing_in_code" ||
+            i.status === "partial" ||
+            i.status === "report_mismatch" ||
+            (i.requiresAutomatedTest && !i.hasAutomatedTest) ||
+            (i.requiresAutomatedTest && !i.hasE2eTest));
+    });
+}
+function formatFailureHistoryBlock(atomId, state, maxPerItem) {
+    const itemState = state.items[atomId];
+    if (!itemState || itemState.history.length === 0)
+        return "";
+    const lines = [
+        "",
+        "**上次修复失败摘要（勿重复同样错误）:**",
+    ];
+    for (const h of itemState.history) {
+        lines.push(`- 第 ${h.round} 轮尝试 (${h.at})`);
+        lines.push(`  - 状态: \`${h.status}\``);
+        lines.push(`  - 错误描述: ${h.detail}`);
+        if (h.missingSignals.length > 0) {
+            lines.push(`  - 仍缺: ${h.missingSignals.join("；")}`);
+        }
+        lines.push(`  - 当时错误代码/证据:`);
+        lines.push("```");
+        lines.push(h.wrongCode);
+        lines.push("```");
+    }
+    const remaining = maxPerItem - itemState.attempts;
+    if (remaining > 0) {
+        lines.push(`> 本项剩余自动修复次数: ${remaining}`);
+    }
+    return lines.join("\n");
+}
+function formatRemediateItemBlock(item, state, maxPerItem) {
+    const attemptNo = (0, prdRemediateState_1.getItemAttempts)(state, item.atomId) + 1;
+    const lines = [
+        `### ${item.atomId}（本项第 ${attemptNo}/${maxPerItem} 次）`,
+        `- 状态: \`${item.status}\``,
+        `- PRD: ${item.atomText.slice(0, 200)}`,
+        `- 问题: ${item.detail}`,
+    ];
+    if (item.missingSignals.length > 0) {
+        lines.push(`- 缺失信号: ${item.missingSignals.join("；")}`);
+    }
+    lines.push("- 当前错误代码/证据:");
+    lines.push("```");
+    lines.push((0, prdRemediateState_1.formatWrongCodeSnippet)(item));
+    lines.push("```");
+    lines.push(formatFailureHistoryBlock(item.atomId, state, maxPerItem));
+    return lines.join("\n");
+}
+function buildRemediatePrompt(args) {
+    const itemBlocks = args.failedItems
+        .slice(0, 30)
+        .map((i) => formatRemediateItemBlock(i, args.remediateState, args.maxPerItem))
+        .join("\n\n");
+    return [
+        `你在项目内执行 PRD 不一致自动修复（runId=${args.runId}，change=${args.change}，全局第 ${args.round} 轮）。`,
+        `本轮须修复 **${args.failedItems.length}** 项；**每项最多自动修复 ${args.maxPerItem} 次**，失败后须根据「上次修复失败摘要」换思路重试。`,
+        "",
+        "## 强制规则",
+        "1. **以 PRD 为准改代码**，禁止改 PRD 迁就实现。",
+        "2. 必读：`source/PRD.md`、`09-PRD语义diff报告.md`、`05-验收清单.md`。",
+        "3. 执行 **/opsx-apply** 工作流（openspec-apply-change → tdd-script → delivery-pipeline 相关 skill）。",
+        "4. 为每条失败项补代码 + 测试（e2e/ 须引用 `PRD-XXX` 或 PRD 字面量断言）。",
+        "5. **禁止揣摩、禁止兜底**；无法确定时不要改，留给人工确认。",
+        "6. 修复后更新 `08-PRD一致性复查报告.md` 对应行（证据路径+行号）。",
+        "7. **重试项必须先阅读下方「上次修复失败摘要」**，避免重复同样错误实现。",
+        "",
+        "## 本次须修复条目（仅剩余失败项；含错误代码与历史摘要）",
+        itemBlocks || "（无条目）",
+        "",
+        "## 完成判定",
+        "全部可机械修复项已按 PRD 改完且可重新通过 prd-diff 时，输出：`PRD_REMEDIATE=COMPLETE`",
+        "若本轮无法修复任何项，输出：`PRD_REMEDIATE=PARTIAL`",
+    ].join("\n");
+}
+async function writeRemediateBrief(outputRoot, round, prompt, agent) {
+    const hint = (0, agentRemediateInvoke_1.agentRemediateHint)(agent);
+    await (0, fs_1.writeTextFileEnsuredDir)(path_1.default.join(outputRoot, `10-PRD自动修复指引-第${round}轮.md`), [
+        `# PRD 自动修复指引（第 ${round} 轮）`,
+        "",
+        "> 由 `sdd-flow-kit prd-remediate` 根据 `09-PRD语义diff报告.md` 生成。",
+        "> 每项最多 3 次；重试时会附带上次错误代码与描述摘要。",
+        `> ${hint}`,
+        "",
+        prompt,
+    ].join("\n"));
+}
+function replaceTableRowVerdict(content, prdId, verdict, noteSuffix) {
+    const lines = content.split("\n");
+    return lines
+        .map((line) => {
+        var _a, _b;
+        const trimmed = line.trim();
+        if (!trimmed.startsWith("|"))
+            return line;
+        const cells = trimmed
+            .split("|")
+            .map((c) => c.trim())
+            .filter((_, i, arr) => i > 0 && i < arr.length - 1);
+        if (((_a = cells[0]) === null || _a === void 0 ? void 0 : _a.toUpperCase()) !== prdId)
+            return line;
+        if (cells.length < 5)
+            return line;
+        cells[3] = verdict;
+        const note = (_b = cells[4]) !== null && _b !== void 0 ? _b : "";
+        if (!note.includes(noteSuffix)) {
+            cells[4] = `${note} ${noteSuffix}`.trim();
+        }
+        return `| ${cells.join(" | ")} |`;
+    })
+        .join("\n");
+}
+/** 单项达上限仍失败后，写入 08 待人工确认汇总 */
+async function escalateFailuresToHumanConfirm(outputRoot, items, maxPerItem) {
+    var _a;
+    const reportPath = path_1.default.join(outputRoot, "08-PRD一致性复查报告.md");
+    let content = (_a = (await (0, fs_1.readFileIfExists)(reportPath))) !== null && _a !== void 0 ? _a : "";
+    if (!content)
+        return;
+    const reason = `单项自动修复 ${maxPerItem} 次仍未通过 prd-diff（${new Date().toISOString()}）`;
+    for (const item of items) {
+        content = replaceTableRowVerdict(content, item.atomId, "待人工确认", "| escalated-by-prd-remediate");
+    }
+    content = content.replace(/- \*\*复查状态\*\*[：:].*/, `- **复查状态**：\`待人工确认（单项自动修复${maxPerItem}次未果）\``);
+    const newRows = items
+        .map((i) => `| ${i.atomId} | ${i.atomText.replace(/\|/g, "/").slice(0, 80)} | ${reason}；${i.detail.replace(/\|/g, "/")} | 产品/需求负责人 |`)
+        .join("\n");
+    if (content.includes("| （无则写「无」） |")) {
+        content = content.replace("| （无则写「无」） | | | |", newRows);
+    }
+    else {
+        content = content.replace("## 待人工确认汇总", `## 待人工确认汇总\n\n${newRows}`);
+    }
+    await (0, fs_1.writeTextFileEnsuredDir)(reportPath, content);
+    await (0, fs_1.writeTextFileEnsuredDir)(path_1.default.join(outputRoot, ".prd-remediate-escalated.json"), `${JSON.stringify({
+        maxPerItem,
+        at: new Date().toISOString(),
+        atomIds: items.map((i) => i.atomId),
+        reason,
+    }, null, 2)}\n`);
+}
+function updateStateAfterRound(state, targetedIds, afterFailed, round) {
+    const afterMap = new Map(afterFailed.map((i) => [i.atomId, i]));
+    for (const atomId of targetedIds) {
+        const still = afterMap.get(atomId);
+        if (!still) {
+            (0, prdRemediateState_1.clearItemFromState)(state, atomId);
+        }
+        else {
+            (0, prdRemediateState_1.recordItemFailure)(state, still, round);
+        }
+    }
+}
+/**
+ * 失败 → /opsx-apply 按 09 修 → prd-diff。
+ * 每项最多 maxAttempts 次；每轮只修剩余失败项；重试时附带上次错误代码与描述摘要。
+ */
+async function runPrdRemediateLoop(options) {
+    var _a;
+    const maxPerItem = (_a = options.maxAttempts) !== null && _a !== void 0 ? _a : exports.MAX_PRD_FIX_RETRIES;
+    const agent = await (0, agentRemediateInvoke_1.resolveRemediateAgent)(options.projectRoot, options.agent);
+    let diff = await options.runDiff();
+    if (diff.ok) {
+        await (0, prdRemediateState_1.clearRemediateState)(options.outputRoot);
+        return { ok: true, detail: "PRD 语义 diff 已通过，无需修复", attempts: 0, escalated: false, needUserConfirm: false };
+    }
+    if (options.dryRun) {
+        const failed = collectRemediableItems(diff.semantic);
+        return {
+            ok: false,
+            detail: `dry-run: would remediate ${failed.length} items (max ${maxPerItem} attempts each)`,
+            attempts: 0,
+            escalated: false,
+            needUserConfirm: false,
+        };
+    }
+    let state = await (0, prdRemediateState_1.loadRemediateState)(options.outputRoot);
+    let round = 0;
+    while (round < exports.MAX_REMEDIATE_ROUNDS) {
+        const failed = collectRemediableItems(diff.semantic);
+        if (failed.length === 0) {
+            break;
+        }
+        const eligible = (0, prdRemediateState_1.filterEligibleItems)(failed, state, maxPerItem);
+        const exhausted = (0, prdRemediateState_1.filterExhaustedItems)(failed, state, maxPerItem);
+        if (eligible.length === 0) {
+            if (exhausted.length > 0) {
+                await escalateFailuresToHumanConfirm(options.outputRoot, exhausted, maxPerItem);
+                return {
+                    ok: false,
+                    detail: `${exhausted.length} 项已达单项 ${maxPerItem} 次上限仍未通过，已写入 08 待人工确认汇总`,
+                    attempts: round,
+                    escalated: true,
+                    needUserConfirm: true,
+                };
+            }
+            break;
+        }
+        round += 1;
+        const targetedIds = new Set(eligible.map((i) => i.atomId));
+        const prompt = buildRemediatePrompt({
+            runId: options.runId,
+            change: options.change,
+            round,
+            maxPerItem,
+            outputRoot: options.outputRoot,
+            failedItems: eligible,
+            remediateState: state,
+        });
+        await writeRemediateBrief(options.outputRoot, round, prompt, agent);
+        await (0, agentRemediateInvoke_1.invokeAgentOpsxRemediate)({
+            agent,
+            projectRoot: options.projectRoot,
+            outputRoot: options.outputRoot,
+            prompt,
+            attempt: round,
+        });
+        diff = await options.runDiff();
+        const afterFailed = collectRemediableItems(diff.semantic);
+        updateStateAfterRound(state, targetedIds, afterFailed, round);
+        await (0, prdRemediateState_1.saveRemediateState)(options.outputRoot, state);
+        if (diff.ok) {
+            await (0, prdRemediateState_1.clearRemediateState)(options.outputRoot);
+            return {
+                ok: true,
+                detail: `PRD 自动修复成功（${agent}，${round} 轮后 prd-diff 通过）`,
+                attempts: round,
+                escalated: false,
+                needUserConfirm: false,
+            };
+        }
+        const newlyExhausted = (0, prdRemediateState_1.filterExhaustedItems)(afterFailed, state, maxPerItem);
+        if (newlyExhausted.length > 0 && (0, prdRemediateState_1.filterEligibleItems)(afterFailed, state, maxPerItem).length === 0) {
+            await escalateFailuresToHumanConfirm(options.outputRoot, newlyExhausted, maxPerItem);
+            return {
+                ok: false,
+                detail: `${newlyExhausted.length} 项已达单项 ${maxPerItem} 次上限仍未通过，已写入 08 待人工确认汇总`,
+                attempts: round,
+                escalated: true,
+                needUserConfirm: true,
+            };
+        }
+    }
+    const stillFailed = collectRemediableItems(diff.semantic);
+    const exhausted = (0, prdRemediateState_1.filterExhaustedItems)(stillFailed, state, maxPerItem);
+    if (exhausted.length > 0) {
+        await escalateFailuresToHumanConfirm(options.outputRoot, exhausted, maxPerItem);
+        return {
+            ok: false,
+            detail: `${exhausted.length} 项已达单项 ${maxPerItem} 次上限仍未通过，已写入 08 待人工确认汇总`,
+            attempts: round,
+            escalated: true,
+            needUserConfirm: true,
+        };
+    }
+    if (stillFailed.length > 0) {
+        return {
+            ok: false,
+            detail: `prd-diff 未通过，仍有 ${stillFailed.length} 项可自动修复但已达全局轮数上限`,
+            attempts: round,
+            escalated: false,
+            needUserConfirm: false,
+        };
+    }
+    return {
+        ok: false,
+        detail: "prd-diff 未通过但无可自动修复项",
+        attempts: round,
+        escalated: false,
+        needUserConfirm: false,
+    };
+}

package/dist/core/prdRemediateState.js

@@ -0,0 +1,135 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PRD_REMEDIATE_STATE_FILE = void 0;
+exports.emptyRemediateState = emptyRemediateState;
+exports.loadRemediateState = loadRemediateState;
+exports.saveRemediateState = saveRemediateState;
+exports.clearRemediateState = clearRemediateState;
+exports.formatWrongCodeSnippet = formatWrongCodeSnippet;
+exports.snapshotItemFailure = snapshotItemFailure;
+exports.recordItemFailure = recordItemFailure;
+exports.clearItemFromState = clearItemFromState;
+exports.getItemAttempts = getItemAttempts;
+exports.filterEligibleItems = filterEligibleItems;
+exports.filterExhaustedItems = filterExhaustedItems;
+const path_1 = __importDefault(require("path"));
+const fs_1 = require("./fs");
+exports.PRD_REMEDIATE_STATE_FILE = ".prd-remediate-state.json";
+function emptyRemediateState() {
+    return { updatedAt: new Date().toISOString(), items: {} };
+}
+async function loadRemediateState(outputRoot) {
+    var _a, _b;
+    const raw = await (0, fs_1.readFileIfExists)(path_1.default.join(outputRoot, exports.PRD_REMEDIATE_STATE_FILE));
+    if (!raw)
+        return emptyRemediateState();
+    try {
+        const parsed = JSON.parse(raw);
+        return {
+            updatedAt: (_a = parsed.updatedAt) !== null && _a !== void 0 ? _a : new Date().toISOString(),
+            items: (_b = parsed.items) !== null && _b !== void 0 ? _b : {},
+        };
+    }
+    catch {
+        return emptyRemediateState();
+    }
+}
+async function saveRemediateState(outputRoot, state) {
+    state.updatedAt = new Date().toISOString();
+    await (0, fs_1.writeTextFileEnsuredDir)(path_1.default.join(outputRoot, exports.PRD_REMEDIATE_STATE_FILE), `${JSON.stringify(state, null, 2)}\n`);
+}
+async function clearRemediateState(outputRoot) {
+    const { unlink } = await Promise.resolve().then(() => __importStar(require("fs/promises")));
+    try {
+        await unlink(path_1.default.join(outputRoot, exports.PRD_REMEDIATE_STATE_FILE));
+    }
+    catch {
+        /* ignore */
+    }
+}
+/** 从语义 diff 项提取「错误代码/证据」摘要 */
+function formatWrongCodeSnippet(item) {
+    if (item.codeHits.length > 0) {
+        return item.codeHits
+            .slice(0, 5)
+            .map((h) => `${h.file}:${h.line}\n  ${h.snippet}`)
+            .join("\n");
+    }
+    if (item.status === "missing_in_code") {
+        return "（代码库中未找到 PRD 要求的实现或字面量）";
+    }
+    if (item.missingSignals.length > 0) {
+        return `（缺失 PRD 字面量: ${item.missingSignals.join("；")}）`;
+    }
+    return "（无代码命中，见 detail）";
+}
+function snapshotItemFailure(item, round) {
+    return {
+        round,
+        at: new Date().toISOString(),
+        status: item.status,
+        detail: item.detail,
+        wrongCode: formatWrongCodeSnippet(item),
+        missingSignals: [...item.missingSignals],
+    };
+}
+function recordItemFailure(state, item, round) {
+    var _a;
+    const prev = (_a = state.items[item.atomId]) !== null && _a !== void 0 ? _a : { attempts: 0, history: [] };
+    const record = snapshotItemFailure(item, round);
+    state.items[item.atomId] = {
+        attempts: prev.attempts + 1,
+        history: [...prev.history, record].slice(-5),
+    };
+}
+function clearItemFromState(state, atomId) {
+    delete state.items[atomId];
+}
+function getItemAttempts(state, atomId) {
+    var _a, _b;
+    return (_b = (_a = state.items[atomId]) === null || _a === void 0 ? void 0 : _a.attempts) !== null && _b !== void 0 ? _b : 0;
+}
+/** 仍可自动修复的项（未达单项上限） */
+function filterEligibleItems(failed, state, maxPerItem) {
+    return failed.filter((i) => getItemAttempts(state, i.atomId) < maxPerItem);
+}
+/** 已达单项上限、仍失败的项 */
+function filterExhaustedItems(failed, state, maxPerItem) {
+    return failed.filter((i) => getItemAttempts(state, i.atomId) >= maxPerItem);
+}