sdd-flow-kit 1.3.6 → 1.3.11

package/dist/core/prdCoverage.js

@@ -0,0 +1,398 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.findTestFiles = findTestFiles;
+exports.parseReviewReportTable = parseReviewReportTable;
+exports.writePrdAtomsManifest = writePrdAtomsManifest;
+exports.loadPrdAtomsFromManifest = loadPrdAtomsFromManifest;
+exports.checkPrdCoverage = checkPrdCoverage;
+exports.writePrdCoveragePassMarker = writePrdCoveragePassMarker;
+const promises_1 = __importDefault(require("fs/promises"));
+const path_1 = __importDefault(require("path"));
+const acMatrix_1 = require("./acMatrix");
+const fs_1 = require("./fs");
+const prdParse_1 = require("./prdParse");
+const prdSemanticDiff_1 = require("./prdSemanticDiff");
+const VALID_VERDICTS = ["一致", "不一致-按PRD修复", "待人工确认"];
+/** 禁止在证据/结论中出现的揣摩或兜底措辞 */
+const FORBIDDEN_SPECULATION = [
+    "推测",
+    "兜底",
+    "暂定",
+    "可能",
+    "大概",
+    "应该可以",
+    "或沿用",
+    "默认处理",
+    "先这样",
+    "暂时",
+    "估计",
+    "猜测",
+    "或许",
+];
+const TEST_FILE_RE = /\.(spec|test)\.(t|j)sx?$/i;
+const E2E_DIR_RE = /(^|\/)(e2e|playwright)(\/|$)/i;
+async function walkFiles(dir, out) {
+    let entries;
+    try {
+        entries = await promises_1.default.readdir(dir, { withFileTypes: true });
+    }
+    catch {
+        return;
+    }
+    for (const ent of entries) {
+        if (ent.name === "node_modules" || ent.name === ".git" || ent.name === "dist")
+            continue;
+        const full = path_1.default.join(dir, ent.name);
+        if (ent.isDirectory()) {
+            await walkFiles(full, out);
+        }
+        else if (TEST_FILE_RE.test(ent.name)) {
+            out.push(full);
+        }
+    }
+}
+async function findTestFiles(pkgRoot) {
+    const roots = ["e2e", "tests", "test", "__tests__", "playwright", "src"];
+    const files = [];
+    for (const r of roots) {
+        await walkFiles(path_1.default.join(pkgRoot, r), files);
+    }
+    return [...new Set(files)];
+}
+function parseReviewReportTable(content) {
+    var _a, _b, _c, _d, _e, _f;
+    const rows = [];
+    for (const line of content.split("\n")) {
+        const trimmed = line.trim();
+        if (!trimmed.startsWith("|"))
+            continue;
+        if (/^\|\s*[-:]+/.test(trimmed))
+            continue;
+        if (/^\|\s*PRD-ID\s*\|/i.test(trimmed))
+            continue;
+        const cells = trimmed
+            .split("|")
+            .map((c) => c.trim())
+            .filter((_, i, arr) => i > 0 && i < arr.length - 1);
+        if (cells.length < 5)
+            continue;
+        const prdId = (_b = (_a = cells[0]) === null || _a === void 0 ? void 0 : _a.toUpperCase()) !== null && _b !== void 0 ? _b : "";
+        if (!/^PRD-\d{3,}$/.test(prdId))
+            continue;
+        rows.push({
+            prdId,
+            prdText: (_c = cells[1]) !== null && _c !== void 0 ? _c : "",
+            codeEvidence: (_d = cells[2]) !== null && _d !== void 0 ? _d : "",
+            verdict: (_e = cells[3]) !== null && _e !== void 0 ? _e : "",
+            note: (_f = cells[4]) !== null && _f !== void 0 ? _f : "",
+        });
+    }
+    return rows;
+}
+function hasForbiddenSpeculation(text) {
+    for (const word of FORBIDDEN_SPECULATION) {
+        if (text.includes(word))
+            return word;
+    }
+    return null;
+}
+async function writePrdAtomsManifest(outputRoot, atoms) {
+    await (0, fs_1.writeTextFileEnsuredDir)(path_1.default.join(outputRoot, ".prd-review-atoms.json"), `${JSON.stringify({ count: atoms.length, atoms }, null, 2)}\n`);
+}
+async function loadPrdAtomsFromManifest(outputRoot) {
+    var _a;
+    const raw = await (0, fs_1.readFileIfExists)(path_1.default.join(outputRoot, ".prd-review-atoms.json"));
+    if (!raw)
+        return [];
+    try {
+        const j = JSON.parse(raw);
+        return (_a = j.atoms) !== null && _a !== void 0 ? _a : [];
+    }
+    catch {
+        return [];
+    }
+}
+function checkAcTestMapping(items, testContents) {
+    var _a;
+    const checks = [];
+    // P0 全量 + 所有声明 e2e 的 AC（含 P1/P2 边缘场景）
+    const mustCover = items.filter((i) => { var _a; return /^P0$/i.test(i.priority.trim()) || /e2e/i.test((_a = i.testType) !== null && _a !== void 0 ? _a : ""); });
+    for (const ac of mustCover) {
+        const bracket = `[${ac.id}]`;
+        const hits = testContents.filter((t) => t.content.includes(bracket) || t.content.includes(ac.id));
+        const e2eRequired = /e2e/i.test((_a = ac.testType) !== null && _a !== void 0 ? _a : "");
+        const e2eHits = hits.filter((h) => E2E_DIR_RE.test(h.file.replace(/\\/g, "/")));
+        if (hits.length === 0) {
+            checks.push({
+                name: `ac-test-${ac.id}`,
+                ok: false,
+                detail: `${ac.id}(${ac.priority}) 未在测试文件中找到 [${ac.id}] 映射`,
+            });
+            continue;
+        }
+        if (e2eRequired && e2eHits.length === 0) {
+            checks.push({
+                name: `ac-e2e-${ac.id}`,
+                ok: false,
+                detail: `${ac.id} 测试类型含 e2e，但 e2e/ 或 playwright/ 下无对应测试`,
+            });
+            continue;
+        }
+        checks.push({
+            name: `ac-test-${ac.id}`,
+            ok: true,
+            detail: e2eRequired
+                ? `${ac.id} 已映射（含 e2e: ${e2eHits.map((h) => path_1.default.basename(h.file)).join(", ")})`
+                : `${ac.id} 已映射: ${hits.map((h) => path_1.default.basename(h.file)).join(", ")}`,
+        });
+    }
+    return checks;
+}
+function checkSemanticDiffItems(semantic) {
+    const checks = [];
+    checks.push({
+        name: "semantic-diff",
+        ok: semantic.ok,
+        detail: semantic.ok
+            ? `语义 diff 通过（matched=${semantic.summary.matched}, unverifiable=${semantic.summary.unverifiable}）`
+            : `语义 diff 未通过: missing=${semantic.summary.missing}, partial=${semantic.summary.partial}, reportMismatch=${semantic.summary.reportMismatch}, missingTest=${semantic.summary.missingTest}, missingE2e=${semantic.summary.missingE2e}`,
+    });
+    const mismatches = semantic.items.filter((i) => i.status === "report_mismatch").slice(0, 6);
+    if (mismatches.length > 0) {
+        checks.push({
+            name: "semantic-report-align",
+            ok: false,
+            detail: `08 报告与脚本 diff 不一致: ${mismatches.map((m) => `${m.atomId}(${m.detail})`).join("; ")}`,
+        });
+    }
+    else {
+        checks.push({
+            name: "semantic-report-align",
+            ok: true,
+            detail: "08 报告结论与脚本语义 diff 一致",
+        });
+    }
+    const missingCode = semantic.items.filter((i) => i.status === "missing_in_code").slice(0, 6);
+    if (missingCode.length > 0) {
+        checks.push({
+            name: "semantic-code-presence",
+            ok: false,
+            detail: `PRD 字面量在代码中缺失: ${missingCode.map((m) => { var _a; return `${m.atomId}「${(_a = m.missingSignals[0]) !== null && _a !== void 0 ? _a : m.atomText.slice(0, 20)}」`; }).join("; ")}`,
+        });
+    }
+    else {
+        checks.push({
+            name: "semantic-code-presence",
+            ok: true,
+            detail: "可验证 PRD 字面量均在代码中出现",
+        });
+    }
+    const missingTests = semantic.items
+        .filter((i) => i.requiresAutomatedTest && !i.hasAutomatedTest)
+        .slice(0, 8);
+    if (missingTests.length > 0) {
+        checks.push({
+            name: "semantic-test-coverage",
+            ok: false,
+            detail: `须自动化测试但未覆盖: ${missingTests.map((m) => m.atomId).join(", ")}（须在 e2e/ 或测试中引用 PRD-ID 或 PRD 字面量）`,
+        });
+    }
+    else {
+        checks.push({
+            name: "semantic-test-coverage",
+            ok: true,
+            detail: `全部 ${semantic.summary.requiresTest} 条可验证 PRD 均有自动化测试引用`,
+        });
+    }
+    const missingE2e = semantic.items
+        .filter((i) => i.requiresAutomatedTest && !i.hasE2eTest)
+        .slice(0, 8);
+    if (missingE2e.length > 0) {
+        checks.push({
+            name: "semantic-e2e-coverage",
+            ok: false,
+            detail: `须 E2E 但未覆盖: ${missingE2e.map((m) => m.atomId).join(", ")}（在 e2e/ 中引用 PRD-ID 或断言 PRD 字面量）`,
+        });
+    }
+    else {
+        checks.push({
+            name: "semantic-e2e-coverage",
+            ok: true,
+            detail: "全部可验证 PRD 条目均有 E2E 测试引用",
+        });
+    }
+    const badEvidence = semantic.items
+        .filter((i) => i.reportVerdict === "一致" && !i.reportEvidenceValid && i.signals.length > 0)
+        .slice(0, 6);
+    if (badEvidence.length > 0) {
+        checks.push({
+            name: "evidence-verified",
+            ok: false,
+            detail: `08 证据无法核对: ${badEvidence.map((m) => m.atomId).join(", ")}（路径不存在或行内无 PRD 字面量）`,
+        });
+    }
+    else {
+        checks.push({
+            name: "evidence-verified",
+            ok: true,
+            detail: "08 报告中「一致」项的证据路径与字面量可机械核对",
+        });
+    }
+    return checks;
+}
+/**
+ * gate prd-coverage：PRD 最细粒度条目全覆盖 + 08 复查报告合规 + P0 AC 测试映射。
+ */
+async function checkPrdCoverage(outputRoot, pkgRoot) {
+    const checks = [];
+    const prdContent = await (0, fs_1.readFileIfExists)(path_1.default.join(outputRoot, "source", "PRD.md"));
+    if (!prdContent) {
+        checks.push({ name: "prd-source", ok: false, detail: "缺少 source/PRD.md" });
+        return { ok: false, checks };
+    }
+    let atoms = await loadPrdAtomsFromManifest(outputRoot);
+    if (atoms.length === 0) {
+        atoms = (0, prdParse_1.parsePrdAtoms)(prdContent);
+        if (atoms.length > 0) {
+            await writePrdAtomsManifest(outputRoot, atoms);
+        }
+    }
+    if (atoms.length === 0) {
+        checks.push({ name: "prd-atoms", ok: false, detail: "PRD 未解析到任何原子条目" });
+        return { ok: false, checks };
+    }
+    checks.push({
+        name: "prd-atoms",
+        ok: true,
+        detail: `PRD 原子条目 ${atoms.length} 条（最细粒度）`,
+    });
+    const reportPath = path_1.default.join(outputRoot, "08-PRD一致性复查报告.md");
+    const reportContent = await (0, fs_1.readFileIfExists)(reportPath);
+    if (!reportContent || reportContent.trim().length < 200) {
+        checks.push({
+            name: "review-report",
+            ok: false,
+            detail: "缺少 08-PRD一致性复查报告.md，请先执行: npx sdd-flow-kit prd-review",
+        });
+        return { ok: false, checks };
+    }
+    if (!/复查状态[：:]\s*[`「]*复查完成/.test(reportContent)) {
+        checks.push({
+            name: "review-status",
+            ok: false,
+            detail: "08 报告未标注「复查状态：复查完成」",
+        });
+    }
+    else {
+        checks.push({ name: "review-status", ok: true, detail: "复查状态：复查完成" });
+    }
+    const reportRows = parseReviewReportTable(reportContent);
+    const rowById = new Map(reportRows.map((r) => [r.prdId, r]));
+    const missingInReport = atoms.filter((a) => !rowById.has(a.id));
+    if (missingInReport.length > 0) {
+        checks.push({
+            name: "report-coverage",
+            ok: false,
+            detail: `08 报告缺少 ${missingInReport.length} 条 PRD 条目: ${missingInReport
+                .slice(0, 6)
+                .map((a) => a.id)
+                .join(", ")}${missingInReport.length > 6 ? "..." : ""}`,
+        });
+    }
+    else {
+        checks.push({
+            name: "report-coverage",
+            ok: true,
+            detail: `08 报告已覆盖全部 ${atoms.length} 条 PRD 原子条目`,
+        });
+    }
+    const invalidVerdicts = [];
+    const needFix = [];
+    const needHuman = [];
+    const speculationHits = [];
+    const emptyEvidence = [];
+    for (const atom of atoms) {
+        const row = rowById.get(atom.id);
+        if (!row)
+            continue;
+        if (!VALID_VERDICTS.includes(row.verdict)) {
+            invalidVerdicts.push(atom.id);
+        }
+        if (row.verdict === "不一致-按PRD修复")
+            needFix.push(atom.id);
+        if (row.verdict === "待人工确认")
+            needHuman.push(atom.id);
+        const evidence = row.codeEvidence.trim();
+        if (!evidence || evidence.length < 8 || /（填写）|待填写|TBD/i.test(evidence)) {
+            emptyEvidence.push(atom.id);
+        }
+        const combined = `${row.codeEvidence} ${row.note} ${row.verdict}`;
+        const forbidden = hasForbiddenSpeculation(combined);
+        if (forbidden)
+            speculationHits.push(`${atom.id}(${forbidden})`);
+    }
+    checks.push({
+        name: "verdict-valid",
+        ok: invalidVerdicts.length === 0,
+        detail: invalidVerdicts.length === 0
+            ? "全部结论为：一致 | 不一致-按PRD修复 | 待人工确认"
+            : `无效结论: ${invalidVerdicts.join(", ")}`,
+    });
+    checks.push({
+        name: "no-speculation",
+        ok: speculationHits.length === 0,
+        detail: speculationHits.length === 0
+            ? "未发现揣摩/兜底措辞"
+            : `含禁止措辞: ${speculationHits.slice(0, 8).join(", ")}`,
+    });
+    checks.push({
+        name: "code-evidence",
+        ok: emptyEvidence.length === 0,
+        detail: emptyEvidence.length === 0
+            ? "每条均有可核对代码证据（文件路径+行号/选择器/断言）"
+            : `缺少代码证据: ${emptyEvidence.slice(0, 8).join(", ")}`,
+    });
+    checks.push({
+        name: "no-prd-mismatch-open",
+        ok: needFix.length === 0,
+        detail: needFix.length === 0
+            ? "无未修复的 PRD 不一致项"
+            : `仍须按 PRD 修复: ${needFix.join(", ")}`,
+    });
+    checks.push({
+        name: "no-human-pending",
+        ok: needHuman.length === 0,
+        detail: needHuman.length === 0
+            ? "无待人工确认项"
+            : `待人工确认: ${needHuman.join(", ")}（见 08 报告「待人工确认汇总」）`,
+    });
+    // ---- 脚本级 PRD 语义 diff（独立于 AI 填表） ----
+    const reportRowMap = new Map(reportRows.map((r) => [r.prdId, { verdict: r.verdict, codeEvidence: r.codeEvidence }]));
+    const semantic = await (0, prdSemanticDiff_1.runPrdSemanticDiff)({ pkgRoot, atoms, reportRows: reportRowMap });
+    await (0, prdSemanticDiff_1.writeSemanticDiffArtifacts)(outputRoot, semantic);
+    checks.push(...checkSemanticDiffItems(semantic));
+    const acParsed = await (0, acMatrix_1.parseAcMatrix)(outputRoot);
+    if (!acParsed.ok) {
+        checks.push({ name: "ac-matrix", ok: false, detail: acParsed.detail });
+    }
+    else {
+        checks.push({ name: "ac-matrix", ok: true, detail: acParsed.detail });
+        const testFiles = await findTestFiles(pkgRoot);
+        const testContents = await Promise.all(testFiles.map(async (f) => {
+            var _a;
+            return ({
+                file: f,
+                content: (_a = (await (0, fs_1.readFileIfExists)(f))) !== null && _a !== void 0 ? _a : "",
+            });
+        }));
+        checks.push(...checkAcTestMapping(acParsed.items, testContents));
+    }
+    const ok = checks.every((c) => c.ok);
+    return { ok, checks };
+}
+async function writePrdCoveragePassMarker(outputRoot, payload) {
+    await (0, fs_1.writeTextFileEnsuredDir)(path_1.default.join(outputRoot, ".prd-coverage-pass.json"), `${JSON.stringify(payload, null, 2)}\n`);
+}

package/dist/core/prdParse.js

@@ -0,0 +1,88 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parsePrdAtoms = parsePrdAtoms;
+function isTableSeparator(line) {
+    const cells = line
+        .split("|")
+        .map((c) => c.trim())
+        .filter((_, i, arr) => i > 0 && i < arr.length - 1);
+    return cells.length > 0 && cells.every((c) => /^:?-+:?$/.test(c));
+}
+/**
+ * 将 PRD Markdown 拆成最细粒度原子条目（标题 / 列表项 / 表格行 / 实质段落）。
+ */
+function parsePrdAtoms(content) {
+    const lines = content.split("\n");
+    const atoms = [];
+    const sectionStack = [];
+    let counter = 0;
+    let inCodeFence = false;
+    for (let i = 0; i < lines.length; i++) {
+        const raw = lines[i];
+        const trimmed = raw.trim();
+        if (trimmed.startsWith("```")) {
+            inCodeFence = !inCodeFence;
+            continue;
+        }
+        if (inCodeFence || !trimmed || trimmed.startsWith("!["))
+            continue;
+        const headingMatch = trimmed.match(/^(#{1,6})\s+(.+)$/);
+        if (headingMatch) {
+            const level = headingMatch[1].length;
+            const title = headingMatch[2].trim();
+            sectionStack.length = level;
+            sectionStack[level - 1] = title;
+            counter += 1;
+            atoms.push({
+                id: `PRD-${String(counter).padStart(3, "0")}`,
+                sectionPath: sectionStack.filter(Boolean).join(" > "),
+                line: i + 1,
+                text: title,
+                kind: "heading",
+            });
+            continue;
+        }
+        const listMatch = trimmed.match(/^(?:\d+\.|[-*+])\s+(.+)$/);
+        if (listMatch && listMatch[1].trim().length >= 4) {
+            counter += 1;
+            atoms.push({
+                id: `PRD-${String(counter).padStart(3, "0")}`,
+                sectionPath: sectionStack.filter(Boolean).join(" > "),
+                line: i + 1,
+                text: listMatch[1].trim(),
+                kind: "list",
+            });
+            continue;
+        }
+        if (trimmed.startsWith("|")) {
+            if (isTableSeparator(trimmed))
+                continue;
+            const cells = trimmed
+                .split("|")
+                .map((c) => c.trim())
+                .filter((_, idx, arr) => idx > 0 && idx < arr.length - 1);
+            if (cells.length >= 1 && cells.some((c) => c.length > 0)) {
+                counter += 1;
+                atoms.push({
+                    id: `PRD-${String(counter).padStart(3, "0")}`,
+                    sectionPath: sectionStack.filter(Boolean).join(" > "),
+                    line: i + 1,
+                    text: cells.join(" | "),
+                    kind: "table-row",
+                });
+            }
+            continue;
+        }
+        if (trimmed.length >= 12 && !trimmed.startsWith("|")) {
+            counter += 1;
+            atoms.push({
+                id: `PRD-${String(counter).padStart(3, "0")}`,
+                sectionPath: sectionStack.filter(Boolean).join(" > "),
+                line: i + 1,
+                text: trimmed,
+                kind: "paragraph",
+            });
+        }
+    }
+    return atoms;
+}