agent-project-sdlc 0.1.12 → 0.1.14

package/dist/lib/validators.js

@@ -27,6 +27,62 @@ const DESIGN_CATEGORIES = [
         architectureTerms: ["compliance", "permission", "authorization", "audit", "合规", "权限", "审计", "授权", "客户确认", "回执归档"]
     }
 ];
+const TESTING_DISALLOWED_ALLOWED_PATHS = [
+    "package.json",
+    "**/package.json",
+    "package-lock.json",
+    "**/package-lock.json",
+    "npm-shrinkwrap.json",
+    "**/npm-shrinkwrap.json",
+    "pnpm-lock.yaml",
+    "**/pnpm-lock.yaml",
+    "yarn.lock",
+    "**/yarn.lock",
+    "bun.lock",
+    "**/bun.lock",
+    "bun.lockb",
+    "**/bun.lockb",
+    "src/**",
+    "app/**",
+    "lib/**",
+    "server/**",
+    "bin/**",
+    "cli/**",
+    "runtime/**",
+    "scripts/**",
+    "tools/**",
+    "deploy/**",
+    "deployment/**",
+    "infra/**",
+    "ops/**",
+    "systemd/**",
+    ".github/workflows/**",
+    "dockerfile",
+    "dockerfile.*",
+    "docker-compose*.yml",
+    "docker-compose*.yaml",
+    "*.service",
+    "tests/runtime/**",
+    "tests/**/runtime/**"
+];
+const TESTING_DISALLOWED_CHANGED_PATHS = [...TESTING_DISALLOWED_ALLOWED_PATHS, "scripts/**", "tools/**"];
+const TESTING_RUNTIME_FILE_TERMS = ["bootstrap", "cloud", "daemon", "poller", "provider", "runtime", "service", "systemd"];
+const TESTING_ALLOWED_TEST_FILE_TERMS = ["assertion", "fixture", "mock", "smoke"];
+const TEST_REPORT_PATH = ".docs/07_test/TEST_REPORT.md";
+const CURRENT_RELEASE_REPORT_PATH = ".docs/08_release/CURRENT_RELEASE.md";
+const TEST_REPORT_PLACEHOLDER_TERMS = ["pending", "tbd", "todo", "待填", "待补", "placeholder"];
+const TEST_FACT_SOURCE_PHASES = new Set(["TESTING", "RFC_RECALIBRATION"]);
+const TEST_FACT_SOURCE_PATTERNS = [".docs/07_test/**", ".docs/07_test/"];
+const TEST_FACT_SOURCE_REF = /\.docs\/07_test\/[^\s`,)]+/g;
+const RUNNABLE_ENTRY_EXIT_TERMS = [
+    "runnable entry/exit",
+    "entry/exit",
+    "entry points",
+    "entry point",
+    "可运行入口/出口",
+    "入口/出口",
+    "not applicable"
+];
 const validators = {
     "validate-harness": validateHarness,
     "validate-current": validateCurrent,
@@ -73,6 +129,9 @@ async function validateCurrent(projectRoot) {
     const root = await harnessRoot(projectRoot);
     const lifecycle = await readYamlObject(path.join(projectRoot, root, "state", "lifecycle.yaml"));
     const current = String(lifecycle.current_phase ?? "");
+    if (current === "SPRINTING") {
+        return validateDevInternal(projectRoot, { phaseExit: true });
+    }
     const gateByPhase = {
         REQUIREMENT_GATHERING: "validate-pm",
         ARCHITECTING: "validate-design",
@@ -213,6 +272,7 @@ function validateDraftTaskShape(task, index, errors) {
     if (!hasImplementationDoc && !hasResultDocs) {
         errors.push(`${String(task.id ?? prefix)} must define implementation_doc or result_docs`);
     }
+    errors.push(...testFactSourceErrorsForTask(task));
     if (OPEN_TASK_STATUSES.has(String(task.status))) {
         if ("gate_result" in task)
             errors.push(`${String(task.id ?? prefix)} open task must not define gate_result`);
@@ -262,10 +322,49 @@ async function validateCrossCuttingArchitecture(projectRoot, productFiles, techP
     return errors;
 }
 async function validateDev(projectRoot) {
+    return validateDevInternal(projectRoot, { phaseExit: false });
+}
+async function validateDevInternal(projectRoot, options) {
     const root = await harnessRoot(projectRoot);
-    const plan = await validatePlanState(projectRoot, false);
+    const lifecycle = await readYamlObject(path.join(projectRoot, root, "state", "lifecycle.yaml"));
+    const plan = await validatePlanState(projectRoot, !options.phaseExit);
+    const phaseErrors = String(lifecycle.current_phase ?? "") === "SPRINTING" ? [] : ["validate-dev requires lifecycle current_phase SPRINTING"];
+    const openTaskErrors = options.phaseExit ? [] : validateDevOpenTaskState(plan.plan);
+    const pathErrors = options.phaseExit ? [] : await validateChangedPaths(projectRoot, plan.plan, true);
     const draftErrors = await validateDevDraftConsumed(projectRoot, root);
-    return { info: [`validate-dev checked ${plan.taskCount} task(s)`], errors: [...plan.errors, ...draftErrors] };
+    const implementationDocErrors = await validateImplementationDocRunnableEntryExit(projectRoot);
+    return {
+        info: [`validate-dev checked ${plan.taskCount} task(s)${options.phaseExit ? " for phase exit" : ""}`],
+        errors: [...phaseErrors, ...plan.errors, ...openTaskErrors, ...pathErrors, ...draftErrors, ...implementationDocErrors]
+    };
+}
+function validateDevOpenTaskState(plan) {
+    const errors = [];
+    const tasks = Array.isArray(plan.tasks) ? plan.tasks.filter(isRecord) : [];
+    const open = tasks.filter((task) => OPEN_TASK_STATUSES.has(String(task.status)));
+    if (open.length === 0)
+        return errors;
+    const currentTaskId = String(plan.current_task_id ?? "");
+    if (!currentTaskId) {
+        errors.push("validate-dev requires current_task_id when SPRINTING has an open task");
+        return errors;
+    }
+    const currentTask = open.find((task) => String(task.id ?? "") === currentTaskId);
+    if (!currentTask) {
+        errors.push(`current_task_id does not match an open SPRINTING task: ${currentTaskId}`);
+        return errors;
+    }
+    const otherOpen = open.filter((task) => String(task.id ?? "") !== currentTaskId);
+    if (otherOpen.length > 0) {
+        errors.push(`validate-dev supports only the current open task during SPRINTING: ${open.map((task) => task.id).join(", ")}`);
+    }
+    if (String(currentTask.phase ?? "") !== "SPRINTING") {
+        errors.push(`${currentTaskId} must have phase SPRINTING for validate-dev`);
+    }
+    if (typeof currentTask.implementation_doc !== "string" || !currentTask.implementation_doc.trim()) {
+        errors.push(`${currentTaskId} must define implementation_doc for validate-dev`);
+    }
+    return errors;
 }
 async function validateDevDraftConsumed(projectRoot, root) {
     const errors = [];
@@ -291,38 +390,55 @@ async function validateReview(projectRoot) {
         errors.push("Review report must include findings or risks");
     if (!containsAny(text, ["test gap", "测试缺口", "coverage"]))
         errors.push("Review report must include test gaps or coverage notes");
+    if (!containsAny(text, ["entry/exit", "entrypoint", "入口", "出口", "runnable", "可运行"])) {
+        errors.push("Review report must assess runnable entry/exit readiness before TESTING");
+    }
     if (!containsAny(text, ["pass", "blocked", "通过", "阻塞"]))
         errors.push("Review report must include PASS/BLOCKED decision");
     return { info: ["validate-review checked review report"], errors };
 }
 async function validateTest(projectRoot) {
+    const root = await harnessRoot(projectRoot);
+    const lifecycle = await readYamlObject(path.join(projectRoot, root, "state", "lifecycle.yaml"));
     const plan = await validatePlanState(projectRoot, false);
-    const text = (await readText(path.join(projectRoot, ".docs/07_test/TEST_PLAN.md"))).toLowerCase();
     const errors = [...plan.errors];
+    const report = await readTestReport(projectRoot);
+    const text = report ? report.text.toLowerCase() : "";
+    if (!report)
+        errors.push(`Missing test report: expected executed evidence at ${TEST_REPORT_PATH}`);
+    if (containsAny(text, TEST_REPORT_PLACEHOLDER_TERMS)) {
+        errors.push("Test report must contain executed evidence, not pending/TBD/TODO/placeholder content");
+    }
     if (!containsAny(text, ["matrix", "矩阵"]))
-        errors.push("Test plan must include a test matrix");
+        errors.push("Test report must include a test matrix");
     if (!containsAny(text, ["regression", "回归"]))
-        errors.push("Test plan must include regression coverage");
+        errors.push("Test report must include regression evidence");
     if (!containsAny(text, ["coverage gap", "覆盖缺口", "gap"]))
-        errors.push("Test plan must include coverage gaps");
+        errors.push("Test report must include coverage gaps");
+    if (!containsAny(text, ["entry/exit", "entrypoint", "入口", "出口", "runnable", "可运行"])) {
+        errors.push("Test report must state existing runnable entry/exit coverage or blocker status");
+    }
     if (!containsAny(text, ["pass", "blocked", "通过", "阻塞"]))
-        errors.push("Test plan must include PASS/BLOCKED decision");
-    return { info: ["validate-test checked test plan"], errors };
+        errors.push("Test report must include PASS/BLOCKED decision");
+    if (lifecycle.current_phase === "TESTING") {
+        errors.push(...testingBoundaryErrorsForChangedFiles(await changedFiles(projectRoot)));
+    }
+    return { info: [`validate-test checked ${report?.source ?? "missing test report"}`], errors };
 }
 async function validateRelease(projectRoot) {
     const plan = await validatePlanState(projectRoot, false);
-    const docs = await markdownFiles(path.join(projectRoot, ".docs/08_release"));
-    const text = await combinedText(docs);
+    const report = await readReleaseReport(projectRoot);
+    const text = report?.text ?? "";
     const errors = [...plan.errors];
-    if (docs.length === 0)
-        errors.push("No release deliverables found");
+    if (!report)
+        errors.push(`Missing current release report: expected ${CURRENT_RELEASE_REPORT_PATH} or legacy .docs/08_release/*.md`);
     if (!containsAny(text, ["release", "发布"]))
-        errors.push("Release docs must include release notes");
+        errors.push("Current release report must include release notes");
     if (!containsAny(text, ["smoke", "冒烟"]))
-        errors.push("Release docs must include smoke test evidence");
+        errors.push("Current release report must include smoke test evidence");
     if (!containsAny(text, ["rollback", "回滚"]))
-        errors.push("Release docs must include rollback plan");
-    return { info: [`validate-release checked ${docs.length} file(s)`], errors };
+        errors.push("Current release report must include rollback plan");
+    return { info: [`validate-release checked ${report?.source ?? "missing current release report"}`], errors };
 }
 async function validateRfc(projectRoot) {
     const plan = await validatePlanState(projectRoot, false);
@@ -339,6 +455,21 @@ async function validateRfc(projectRoot) {
         errors.push("RFC must include technical impact candidates");
     if (!containsAny(text, ["regression", "回归"]))
         errors.push("RFC must include regression requirements");
+    if (!containsAny(text, ["test fact source impact", "测试事实源影响"])) {
+        errors.push("RFC must include Test Fact Source Impact");
+    }
+    const indexPath = path.join(projectRoot, ".docs/INDEX.md");
+    const indexText = (await pathExists(indexPath)) ? await readText(indexPath) : "";
+    if (!indexText)
+        errors.push("Missing .docs/INDEX.md for RFC test fact source validation");
+    for (const superseded of await supersededTestDocs(docs)) {
+        if (await pathExists(path.join(projectRoot, superseded))) {
+            errors.push(`Superseded test doc still exists in current facts: ${superseded}`);
+        }
+        if (indexText.includes(superseded)) {
+            errors.push(`Superseded test doc still linked from .docs/INDEX.md: ${superseded}`);
+        }
+    }
     const statuses = [...text.matchAll(/status:\s*([a-z_]+)/g)].map((match) => match[1].toUpperCase());
     if (statuses.length === 0)
         errors.push("RFC must include a Status line");
@@ -397,6 +528,7 @@ async function validatePlanState(projectRoot, allowOpen) {
         if (match) {
             maxTaskSequence = Math.max(maxTaskSequence, Number(match[1]));
         }
+        errors.push(...testFactSourceErrorsForTask(task));
         if (["pending", "in_progress", "blocked", "pending_revision"].includes(String(task.status))) {
             if ("gate_result" in task) {
                 errors.push(`Open task ${task.id} must not define gate_result`);
@@ -417,6 +549,7 @@ async function validatePlanState(projectRoot, allowOpen) {
             if (!Array.isArray(task.acceptance_criteria) || task.acceptance_criteria.length === 0) {
                 errors.push(`Open task ${task.id} must define acceptance_criteria`);
             }
+            errors.push(...testingBoundaryErrorsForAllowedPaths(task));
         }
         else {
             errors.push(`Completed task ${task.id} must not remain in plan.yaml`);
@@ -564,6 +697,46 @@ async function readYamlObject(filePath) {
         return {};
     return (parseYaml(await readText(filePath)) ?? {});
 }
+async function readTestReport(projectRoot) {
+    const canonical = path.join(projectRoot, TEST_REPORT_PATH);
+    if (await pathExists(canonical)) {
+        return { text: await readText(canonical), source: TEST_REPORT_PATH };
+    }
+    return undefined;
+}
+async function readReleaseReport(projectRoot) {
+    const canonical = path.join(projectRoot, CURRENT_RELEASE_REPORT_PATH);
+    if (await pathExists(canonical)) {
+        return { text: await readText(canonical), source: CURRENT_RELEASE_REPORT_PATH };
+    }
+    const legacyDocs = await markdownFiles(path.join(projectRoot, ".docs/08_release"));
+    if (legacyDocs.length > 0) {
+        return { text: await combinedText(legacyDocs), source: `legacy .docs/08_release/*.md (${legacyDocs.length} file(s))` };
+    }
+    return undefined;
+}
+async function validateImplementationDocRunnableEntryExit(projectRoot) {
+    const docs = await markdownFiles(path.join(projectRoot, ".docs/04_implementation"));
+    const errors = [];
+    const indexPath = path.join(projectRoot, ".docs/INDEX.md");
+    const indexText = (await pathExists(indexPath)) ? await readText(indexPath) : "";
+    if (docs.length > 0 && !indexText) {
+        errors.push("Missing .docs/INDEX.md for implementation doc validation");
+    }
+    for (const doc of docs) {
+        const relative = repoRelative(projectRoot, doc);
+        const dotted = relative.startsWith(".") ? relative : `.${relative}`;
+        const withoutDocsPrefix = dotted.replace(/^\.docs\//, "");
+        if (indexText && !indexText.includes(dotted) && !indexText.includes(withoutDocsPrefix)) {
+            errors.push(`.docs/INDEX.md does not link implementation doc: ${dotted}`);
+        }
+        const text = await readText(doc);
+        if (!containsAny(text, RUNNABLE_ENTRY_EXIT_TERMS)) {
+            errors.push(`Implementation doc must include Runnable Entry/Exit facts or explicit Not applicable: ${dotted}`);
+        }
+    }
+    return errors;
+}
 async function markdownFiles(root) {
     const files = await listFiles(root);
     return files.filter((file) => {
@@ -579,6 +752,78 @@ function containsAny(text, needles) {
     const lowered = text.toLowerCase();
     return needles.some((needle) => lowered.includes(needle.toLowerCase()));
 }
+function testingBoundaryErrorsForAllowedPaths(task) {
+    if (task.phase !== "TESTING")
+        return [];
+    const allowed = Array.isArray(task.allowed_paths) ? task.allowed_paths.map((item) => String(item)) : [];
+    const blocked = allowed.filter((item) => isTestingBoundaryAllowedPath(item));
+    if (blocked.length === 0)
+        return [];
+    return [
+        `TESTING task allowed_paths must not include product runtime, package/deploy config, or long-running runtime paths: ${blocked.join(", ")}`
+    ];
+}
+function testingBoundaryErrorsForChangedFiles(files) {
+    const blocked = files.filter((file) => isTestingRuntimeBoundaryChange(file));
+    if (blocked.length === 0)
+        return [];
+    return [
+        `TESTING changes must use existing product entrypoints only; move runtime, bootstrap, provider, deploy, or package script changes to SPRINTING/RFC: ${blocked.join(", ")}`
+    ];
+}
+function testFactSourceErrorsForTask(task) {
+    const phase = String(task.phase ?? "");
+    if (TEST_FACT_SOURCE_PHASES.has(phase))
+        return [];
+    const candidates = [...asStringList(task.allowed_paths), ...asStringList(task.result_docs)];
+    const blocked = candidates.filter((candidate) => {
+        const normalized = candidate.replace(/\\/g, "/");
+        return normalized.startsWith(".docs/07_test/") || matchesAny(normalized, TEST_FACT_SOURCE_PATTERNS);
+    });
+    if (blocked.length === 0)
+        return [];
+    return [
+        `Only TESTING or RFC_RECALIBRATION tasks may target current test fact sources under .docs/07_test/**: ${blocked.join(", ")}`
+    ];
+}
+async function supersededTestDocs(docs) {
+    const refs = new Set();
+    for (const doc of docs) {
+        const text = await readText(doc);
+        for (const line of text.split("\n")) {
+            const lowered = line.toLowerCase();
+            if (!lowered.includes("superseded") && !lowered.includes("被替代") && !lowered.includes("失效")) {
+                continue;
+            }
+            for (const match of line.matchAll(TEST_FACT_SOURCE_REF)) {
+                refs.add(normalizeDocRef(match[0]).replace(/[.,;:]$/, ""));
+            }
+        }
+    }
+    return [...refs].filter((ref) => ref.startsWith(".docs/07_test/"));
+}
+function isTestingBoundaryAllowedPath(file) {
+    const lowered = file.replace(/\\/g, "/").toLowerCase();
+    if (["package.json", "package-lock.json", "npm-shrinkwrap.json", "pnpm-lock.yaml", "yarn.lock", "bun.lock", "bun.lockb"].includes(lowered)) {
+        return true;
+    }
+    return matchesAny(lowered, TESTING_DISALLOWED_ALLOWED_PATHS);
+}
+function isTestingRuntimeBoundaryChange(file) {
+    const normalized = file.replace(/\\/g, "/");
+    const lowered = normalized.toLowerCase();
+    if (isTestingBoundaryAllowedPath(lowered) || matchesAny(lowered, TESTING_DISALLOWED_CHANGED_PATHS)) {
+        return true;
+    }
+    if (lowered.startsWith("tests/")) {
+        const name = path.basename(lowered);
+        if (TESTING_ALLOWED_TEST_FILE_TERMS.some((term) => name.includes(term))) {
+            return false;
+        }
+        return TESTING_RUNTIME_FILE_TERMS.some((term) => name.includes(term));
+    }
+    return false;
+}
 function isDevelopmentDraft(task) {
     const taskId = String(task.id ?? "");
     return Boolean(task.implementation_doc) || task.phase === "SPRINTING" || taskId.startsWith("DEV-");
@@ -609,7 +854,7 @@ function taskText(task) {
 }
 export async function changedFiles(projectRoot) {
     try {
-        const { stdout } = await execFileAsync("git", ["status", "--porcelain"], { cwd: projectRoot });
+        const { stdout } = await execFileAsync("git", ["status", "--porcelain", "--untracked-files=all"], { cwd: projectRoot });
         return stdout
             .split("\n")
             .map((line) => line.slice(3).trim())

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "agent-project-sdlc",
-  "version": "0.1.12",
+  "version": "0.1.14",
   "description": "CLI and canonical assets for the AI SDLC Harness workflow.",
   "type": "module",
   "bin": {

package/assets/templates/TEST_PLAN_TEMPLATE.md

@@ -1,29 +0,0 @@
-# Test Plan（测试计划）
-
-## 1. Scope（范围）
-
-- PRD:
-- Technical design:
-- Implementation docs:
-- Review report:
-
-## 2. Test Matrix（测试矩阵）
-
-| 需求（Requirement） | 场景（Scenario） | 测试类型（Test Type） | 测试用例（Test Case） | 结果（Result） |
-|---|---|---|---|---|
-|  |  | unit/integration/e2e/regression |  | pending |
-
-## 3. Regression Checklist（回归检查清单）
-
-- [ ] 
-
-## 4. Coverage Gaps（覆盖缺口）
-
-| 缺口（Gap） | 风险（Risk） | 后续动作（Follow-up） |
-|---|---|---|
-|  |  |  |
-
-## 5. Final Result（最终结论）
-
-- Decision: `PASS` / `BLOCKED`
-- Evidence: