qfai 1.2.13 → 1.3.0

package/dist/index.cjs

@@ -1217,8 +1217,8 @@ function isValidId(value, prefix) {
 }
 
 // src/core/report.ts
-var import_promises18 = require("fs/promises");
-var import_node_path17 = __toESM(require("path"), 1);
+var import_promises19 = require("fs/promises");
+var import_node_path18 = __toESM(require("path"), 1);
 
 // src/core/contractIndex.ts
 var import_promises6 = require("fs/promises");
@@ -1952,8 +1952,8 @@ var import_promises8 = require("fs/promises");
 var import_node_path9 = __toESM(require("path"), 1);
 var import_node_url = require("url");
 async function resolveToolVersion() {
-  if ("1.2.13".length > 0) {
-    return "1.2.13";
+  if ("1.3.0".length > 0) {
+    return "1.3.0";
   }
   try {
     const packagePath = resolvePackageJsonPath();
@@ -2781,6 +2781,24 @@ async function validateCaseCatalogues(root, config) {
 // src/core/validators/delta.ts
 var import_promises11 = require("fs/promises");
 var import_node_path12 = __toESM(require("path"), 1);
+var CHANGE_TYPE_PRIMARY_RE = /^\s*[-*]?\s*change_type_primary\s*:\s*(.+)\s*$/im;
+var CHANGE_TYPE_TAGS_RE = /^\s*[-*]?\s*change_type_tags\s*:\s*(.*)\s*$/im;
+var DO_NOT_RE = /^\s*[-*]?\s*do_not\s*:/im;
+var TEMPTATION_RE = /^\s*[-*]?\s*temptation\s*:/im;
+var ALLOWED_CHANGE_TYPE_PRIMARY = /* @__PURE__ */ new Set([
+  "initial",
+  "behavior",
+  "structural",
+  "ops"
+]);
+var ALLOWED_CHANGE_TYPE_TAGS = /* @__PURE__ */ new Set([
+  "@ui",
+  "@api",
+  "@db",
+  "@nfr",
+  "@docs",
+  "@test"
+]);
 async function validateDeltas(root, config) {
   const specsRoot = resolvePath(root, config, "specsDir");
   const packs = await collectSpecPackDirs(specsRoot);
@@ -2842,10 +2860,8 @@ async function validateDeltas(root, config) {
         )
       );
     } else {
-      const hasRejected = /^\s*(?:[-*]\s*)?rejected\s*:/im.test(
-        decisionRecords.body
-      );
-      if (!hasRejected) {
+      const rejectedBlocks = extractRejectedBlocks(decisionRecords.body);
+      if (rejectedBlocks.length === 0) {
         issues.push(
           issue(
             "QFAI-DELTA-101",
@@ -2858,6 +2874,28 @@ async function validateDeltas(root, config) {
             "rejected \u3092\u6700\u4F4E1\u4EF6\u8A18\u8F09\u3057\u3066\u304F\u3060\u3055\u3044\u3002"
           )
         );
+      } else {
+        const hasDoNot = rejectedBlocks.some((block) => DO_NOT_RE.test(block));
+        const hasTemptation = rejectedBlocks.some(
+          (block) => TEMPTATION_RE.test(block)
+        );
+        if (!hasDoNot || !hasTemptation) {
+          const missing = [];
+          if (!hasDoNot) missing.push("do_not");
+          if (!hasTemptation) missing.push("temptation");
+          issues.push(
+            issue(
+              "QFAI-DELTA-204",
+              `Decision Records \u306B ${missing.join(" / ")} \u304C\u898B\u3064\u304B\u308A\u307E\u305B\u3093\u3002`,
+              "warning",
+              deltaPath,
+              "delta.rejectedDetails",
+              void 0,
+              "change",
+              "rejected \u306B\u306F do_not / temptation \u3092\u6700\u4F4E1\u4EF6\u542B\u3081\u3066\u304F\u3060\u3055\u3044\u3002"
+            )
+          );
+        }
       }
     }
     if (changeLog && decisionRecords) {
@@ -2876,6 +2914,54 @@ async function validateDeltas(root, config) {
         );
       }
     }
+    if (changeLog) {
+      const blocks = extractChangeLogBlocks(text, changeLog);
+      for (const block of blocks) {
+        const primary = extractChangeTypePrimary(block);
+        if (!primary) {
+          issues.push(
+            issue(
+              "QFAI-DELTA-201",
+              "Change Log \u306E CL \u30D6\u30ED\u30C3\u30AF\u306B change_type_primary \u304C\u898B\u3064\u304B\u308A\u307E\u305B\u3093\u3002",
+              "warning",
+              deltaPath,
+              "delta.changeTypePrimary",
+              void 0,
+              "change",
+              "change_type_primary \u3092\u8FFD\u52A0\u3057\u3066\u304F\u3060\u3055\u3044\u3002"
+            )
+          );
+        } else if (!isAllowedChangeTypePrimary(primary)) {
+          issues.push(
+            issue(
+              "QFAI-DELTA-202",
+              `change_type_primary \u304C\u4E0D\u6B63\u3067\u3059: ${primary}`,
+              "warning",
+              deltaPath,
+              "delta.changeTypePrimary",
+              void 0,
+              "change",
+              "change_type_primary \u306F Initial | Behavior | Structural | Ops \u3092\u6307\u5B9A\u3057\u3066\u304F\u3060\u3055\u3044\u3002"
+            )
+          );
+        }
+        const invalidTags = extractInvalidChangeTypeTags(block);
+        if (invalidTags && invalidTags.length > 0) {
+          issues.push(
+            issue(
+              "QFAI-DELTA-203",
+              `change_type_tags \u306B\u7121\u52B9\u306A\u30BF\u30B0\u304C\u3042\u308A\u307E\u3059: ${invalidTags.join(", ")}`,
+              "warning",
+              deltaPath,
+              "delta.changeTypeTags",
+              void 0,
+              "change",
+              "change_type_tags \u306F @ui @api @db @nfr @docs @test \u306E\u307F\u6307\u5B9A\u3057\u3066\u304F\u3060\u3055\u3044\u3002"
+            )
+          );
+        }
+      }
+    }
   }
   return issues;
 }
@@ -2888,6 +2974,98 @@ function findSection(sections, title) {
   }
   return null;
 }
+function extractChangeLogBlocks(text, changeLog) {
+  const lines = text.split(/\r?\n/);
+  const headings = parseHeadings(text).filter(
+    (heading) => heading.level === 3 && heading.line >= changeLog.startLine && heading.line <= changeLog.endLine
+  );
+  if (headings.length === 0) {
+    return [changeLog.body];
+  }
+  const blocks = [];
+  for (let i = 0; i < headings.length; i += 1) {
+    const current = headings[i];
+    if (!current) continue;
+    const next = headings[i + 1];
+    const startLine = current.line + 1;
+    const endLine = Math.min(
+      changeLog.endLine,
+      (next?.line ?? changeLog.endLine + 1) - 1
+    );
+    if (startLine > endLine) {
+      blocks.push("");
+      continue;
+    }
+    blocks.push(lines.slice(startLine - 1, endLine).join("\n"));
+  }
+  return blocks;
+}
+function extractChangeTypePrimary(block) {
+  const match = block.match(CHANGE_TYPE_PRIMARY_RE);
+  const value = match?.[1]?.trim() ?? "";
+  return value.length > 0 ? value : null;
+}
+function extractRejectedBlocks(sectionBody) {
+  const lines = sectionBody.split(/\r?\n/);
+  const blocks = [];
+  let currentIndent = null;
+  let buffer = [];
+  const flush = () => {
+    if (currentIndent === null) {
+      return;
+    }
+    blocks.push(buffer.join("\n"));
+    buffer = [];
+    currentIndent = null;
+  };
+  for (let i = 0; i < lines.length; i += 1) {
+    const line = lines[i] ?? "";
+    const match = line.match(/^(\s*)(?:[-*]\s*)?rejected\s*:(.*)$/i);
+    if (match) {
+      flush();
+      const inlineValue = (match[2] ?? "").trim();
+      if (inlineValue.length > 0) {
+        blocks.push(inlineValue);
+        currentIndent = null;
+      } else {
+        currentIndent = (match[1] ?? "").length;
+      }
+      continue;
+    }
+    if (currentIndent === null) {
+      continue;
+    }
+    const indentMatch = line.match(/^(\s*)/);
+    const indent = (indentMatch?.[1] ?? "").length;
+    if (line.trim().length > 0 && indent <= currentIndent) {
+      flush();
+      i -= 1;
+      continue;
+    }
+    buffer.push(line);
+  }
+  flush();
+  return blocks;
+}
+function extractInvalidChangeTypeTags(block) {
+  const match = block.match(CHANGE_TYPE_TAGS_RE);
+  if (!match) {
+    return null;
+  }
+  const raw = match[1]?.trim() ?? "";
+  if (raw.length === 0) {
+    return [];
+  }
+  const tags = raw.split(/[\s,]+/).map((tag) => tag.trim()).filter((tag) => tag.length > 0);
+  const invalid = tags.filter((tag) => !isAllowedChangeTypeTag(tag));
+  return invalid;
+}
+function isAllowedChangeTypePrimary(value) {
+  return ALLOWED_CHANGE_TYPE_PRIMARY.has(value.trim().toLowerCase());
+}
+function isAllowedChangeTypeTag(value) {
+  return ALLOWED_CHANGE_TYPE_TAGS.has(value.trim().toLowerCase());
+}
 
 // src/core/validators/ids.ts
 var import_promises12 = require("fs/promises");
@@ -3709,12 +3887,45 @@ function validateSpecContent(text, file, requiredSections) {
   return issues;
 }
 
-// src/core/validators/traceability.ts
+// src/core/validators/atddLedger.ts
 var import_promises16 = require("fs/promises");
+var import_node_path17 = __toESM(require("path"), 1);
+async function validateAtddCoverageLedgers(root, config) {
+  const specsRoot = resolvePath(root, config, "specsDir");
+  const entries = await collectSpecEntries(specsRoot);
+  if (entries.length === 0) {
+    return [];
+  }
+  const issues = [];
+  for (const entry of entries) {
+    const ledgerPath = import_node_path17.default.join(entry.dir, "atdd", "coverage-ledger.md");
+    try {
+      await (0, import_promises16.access)(ledgerPath);
+    } catch (error) {
+      if (isMissingFileError2(error)) {
+        issues.push(
+          issue(
+            "QFAI-ATDD-001",
+            "ATDD coverage-ledger.md \u304C\u898B\u3064\u304B\u308A\u307E\u305B\u3093\u3002",
+            "warning",
+            ledgerPath,
+            "atddLedger.exists"
+          )
+        );
+        continue;
+      }
+      throw error;
+    }
+  }
+  return issues;
+}
+
+// src/core/validators/traceability.ts
+var import_promises17 = require("fs/promises");
 var SPEC_TAG_RE3 = /^SPEC-\d{4}$/;
 var BR_TAG_RE2 = /^BR-\d{4}-\d{4}$/;
 var SAMPLE_LIMIT = 20;
-async function validateTraceability(root, config) {
+async function validateTraceability(root, config, phase) {
   const issues = [];
   const specsRoot = resolvePath(root, config, "specsDir");
   const srcRoot = resolvePath(root, config, "srcDir");
@@ -3735,7 +3946,7 @@ async function validateTraceability(root, config) {
   const contractIndex = await buildContractIndex(root, config);
   const contractIds = contractIndex.ids;
   for (const file of specFiles) {
-    const text = await (0, import_promises16.readFile)(file, "utf-8");
+    const text = await (0, import_promises17.readFile)(file, "utf-8");
     extractAllIds(text).forEach((id) => upstreamIds.add(id));
     const parsed = parseSpec(text, file);
     if (parsed.specId) {
@@ -3808,7 +4019,7 @@ async function validateTraceability(root, config) {
     }
   }
   for (const file of scenarioFiles) {
-    const text = await (0, import_promises16.readFile)(file, "utf-8");
+    const text = await (0, import_promises17.readFile)(file, "utf-8");
     extractAllIds(text).forEach((id) => upstreamIds.add(id));
     const scenarioContractRefs = parseContractRefs(text, {
       allowCommentPrefix: true
@@ -4144,18 +4355,22 @@ async function validateTraceability(root, config) {
     );
   } else {
     if (config.validation.traceability.scMustHaveTest && scIdsInScenarios.size) {
+      const ignoredLayers = phase === "atdd" ? /* @__PURE__ */ new Set(["unit", "component"]) : /* @__PURE__ */ new Set();
       const enforcedLayers = /* @__PURE__ */ new Set();
       for (const [scId, refs] of scTestRefs.entries()) {
         if (!refs || refs.size === 0) {
           continue;
         }
         const layer = scIdToLayer.get(scId);
-        if (layer) {
+        if (layer && !ignoredLayers.has(layer)) {
           enforcedLayers.add(layer);
         }
       }
       const deferredLayers = [];
       for (const [layer, scIds] of layerToScIds.entries()) {
+        if (ignoredLayers.has(layer)) {
+          continue;
+        }
         const missing = Array.from(scIds).filter((id) => {
           const refs = scTestRefs.get(id);
           return !refs || refs.size === 0;
@@ -4244,7 +4459,7 @@ async function collectScenarioSpecInfo(entries) {
   for (const entry of entries) {
     let specText = "";
     try {
-      specText = await (0, import_promises16.readFile)(entry.specPath, "utf-8");
+      specText = await (0, import_promises17.readFile)(entry.specPath, "utf-8");
     } catch {
       specText = "";
     }
@@ -4289,7 +4504,7 @@ async function validateCodeReferences(upstreamIds, srcRoot, testsRoot) {
   const pattern = buildIdPattern(Array.from(upstreamIds));
   let found = false;
   for (const file of targetFiles) {
-    const text = await (0, import_promises16.readFile)(file, "utf-8");
+    const text = await (0, import_promises17.readFile)(file, "utf-8");
     if (pattern.test(text)) {
       found = true;
       break;
@@ -4314,9 +4529,139 @@ function buildIdPattern(ids) {
 }
 
 // src/core/validators/traceabilityMatrix.ts
-var import_promises17 = require("fs/promises");
+var import_promises18 = require("fs/promises");
+
+// src/core/traceabilityMatrix.ts
+var SC_ID_RE = /SC-\d{4}-\d{4}/g;
+function parseTraceabilityMatrixStatus(matrixText) {
+  const lines = matrixText.split(/\r?\n/);
+  for (let i = 0; i < lines.length; i += 1) {
+    const headerLine = lines[i];
+    const separatorLine = lines[i + 1];
+    if (!headerLine || !separatorLine) {
+      continue;
+    }
+    if (!headerLine.includes("|") || !separatorLine.includes("|")) {
+      continue;
+    }
+    if (!isSeparatorRow(separatorLine)) {
+      continue;
+    }
+    const headers = splitTableRow(headerLine);
+    if (headers.length === 0) {
+      continue;
+    }
+    const scIndex = findHeaderIndex(headers, ["SC", "Scenario"]);
+    const statusIndex = findHeaderIndex(headers, ["Status", "status"]);
+    if (scIndex === -1) {
+      continue;
+    }
+    const statusBySc = /* @__PURE__ */ new Map();
+    const invalidStatusValues = [];
+    const hasStatusColumn = statusIndex !== -1;
+    for (let row = i + 2; row < lines.length; row += 1) {
+      const line = lines[row];
+      if (!line || !line.includes("|")) {
+        break;
+      }
+      if (isSeparatorRow(line)) {
+        continue;
+      }
+      const cells = splitTableRow(line);
+      const scCell = cells[scIndex] ?? "";
+      const scIds = extractScIds(scCell);
+      if (scIds.length === 0) {
+        continue;
+      }
+      const rawStatus = hasStatusColumn ? cells[statusIndex] ?? "" : "";
+      const normalizedStatus = normalizeStatus(rawStatus);
+      if (rawStatus && !normalizedStatus) {
+        invalidStatusValues.push(rawStatus);
+        continue;
+      }
+      for (const scId of scIds) {
+        const nextStatus = normalizedStatus ?? "implemented";
+        const current = statusBySc.get(scId);
+        if (current === "implemented") {
+          continue;
+        }
+        if (nextStatus === "implemented") {
+          statusBySc.set(scId, "implemented");
+        } else if (!current) {
+          statusBySc.set(scId, "planned");
+        }
+      }
+    }
+    return { statusBySc, invalidStatusValues, hasStatusColumn };
+  }
+  return {
+    statusBySc: /* @__PURE__ */ new Map(),
+    invalidStatusValues: [],
+    hasStatusColumn: false
+  };
+}
+function splitTableRow(line) {
+  const normalized = normalizeTableRow(line);
+  if (!normalized) {
+    return [];
+  }
+  return normalized.split("|").map((cell) => cell.trim());
+}
+function findHeaderIndex(headers, targets) {
+  const normalized = headers.map((header) => header.toLowerCase());
+  for (const target of targets) {
+    const index = normalized.indexOf(target.toLowerCase());
+    if (index !== -1) {
+      return index;
+    }
+  }
+  return -1;
+}
+function extractScIds(text) {
+  const matches = text.match(SC_ID_RE);
+  if (!matches) {
+    return [];
+  }
+  return Array.from(new Set(matches));
+}
+function normalizeStatus(value) {
+  const normalized = value.trim().toLowerCase();
+  if (!normalized) {
+    return null;
+  }
+  if (normalized === "implemented") {
+    return "implemented";
+  }
+  if (normalized === "planned") {
+    return "planned";
+  }
+  return null;
+}
+function isSeparatorRow(line) {
+  const normalized = normalizeTableRow(line);
+  if (!normalized) {
+    return false;
+  }
+  return /^[-\s:|]+$/.test(normalized.trim());
+}
+function normalizeTableRow(line) {
+  const trimmed = line.trim();
+  if (!trimmed.includes("|")) {
+    return null;
+  }
+  let normalized = trimmed;
+  if (normalized.startsWith("|")) {
+    normalized = normalized.slice(1);
+  }
+  if (normalized.endsWith("|")) {
+    normalized = normalized.slice(0, -1);
+  }
+  return normalized;
+}
+
+// src/core/validators/traceabilityMatrix.ts
 var SC_TAG_RE5 = /^SC-\d{4}-\d{4}$/;
-async function validateTraceabilityMatrices(root, config) {
+async function validateTraceabilityMatrices(root, config, phase) {
   const specsRoot = resolvePath(root, config, "specsDir");
   const entries = await collectSpecEntries(specsRoot);
   if (entries.length === 0) {
@@ -4326,7 +4671,7 @@ async function validateTraceabilityMatrices(root, config) {
   for (const entry of entries) {
     let matrixText;
     try {
-      matrixText = await (0, import_promises17.readFile)(entry.traceabilityMatrixPath, "utf-8");
+      matrixText = await (0, import_promises18.readFile)(entry.traceabilityMatrixPath, "utf-8");
     } catch (error) {
       if (isMissingFileError2(error)) {
         issues.push(
@@ -4361,9 +4706,42 @@ async function validateTraceabilityMatrices(root, config) {
         )
       );
     }
+    const statusResult = parseTraceabilityMatrixStatus(matrixText);
+    if (statusResult.hasStatusColumn && statusResult.invalidStatusValues.length > 0) {
+      const invalid = Array.from(new Set(statusResult.invalidStatusValues));
+      issues.push(
+        issue(
+          "QFAI-RTM-004",
+          `traceability-matrix \u306E status \u304C\u4E0D\u6B63\u3067\u3059: ${invalid.join(", ")}`,
+          "error",
+          entry.traceabilityMatrixPath,
+          "traceabilityMatrix.status",
+          invalid
+        )
+      );
+    }
+    const isStrictPhase = phase === "full" || phase === "tdd";
+    if (statusResult.hasStatusColumn && isStrictPhase) {
+      const planned = Array.from(statusResult.statusBySc.entries()).filter(([, status]) => status === "planned").map(([scId]) => scId);
+      if (planned.length > 0) {
+        const uniquePlanned = Array.from(new Set(planned));
+        issues.push(
+          issue(
+            "QFAI-RTM-005",
+            `traceability-matrix \u306B planned \u304C\u6B8B\u3063\u3066\u3044\u307E\u3059: ${uniquePlanned.join(
+              ", "
+            )} (phase=${phase})`,
+            "warning",
+            entry.traceabilityMatrixPath,
+            "traceabilityMatrix.statusPlanned",
+            uniquePlanned
+          )
+        );
+      }
+    }
     let specText = "";
     try {
-      specText = await (0, import_promises17.readFile)(entry.specPath, "utf-8");
+      specText = await (0, import_promises18.readFile)(entry.specPath, "utf-8");
     } catch {
       specText = "";
     }
@@ -4374,13 +4752,13 @@ async function validateTraceabilityMatrices(root, config) {
     const acIds = new Set(specText ? extractIds(specText, "AC") : []);
     const caseIds = new Set(specText ? extractIds(specText, "CASE") : []);
     try {
-      const caseText = await (0, import_promises17.readFile)(entry.caseCataloguePath, "utf-8");
+      const caseText = await (0, import_promises18.readFile)(entry.caseCataloguePath, "utf-8");
       extractIds(caseText, "CASE").forEach((id) => caseIds.add(id));
     } catch {
     }
     let scenarioText = "";
     try {
-      scenarioText = await (0, import_promises17.readFile)(entry.scenarioPath, "utf-8");
+      scenarioText = await (0, import_promises18.readFile)(entry.scenarioPath, "utf-8");
     } catch {
       scenarioText = "";
     }
@@ -4451,20 +4829,22 @@ async function validateTraceabilityMatrices(root, config) {
 }
 
 // src/core/validate.ts
-async function validateProject(root, configResult) {
+async function validateProject(root, configResult, options = {}) {
   const resolved = configResult ?? await loadConfig(root);
   const { config, issues: configIssues } = resolved;
+  const phase = options.phase ?? "full";
   const issues = [
     ...configIssues,
     ...await validatePromptsIntegrity(root, config),
     ...await validateSpecs(root, config),
     ...await validateDeltas(root, config),
     ...await validateScenarios(root, config),
+    ...phase === "atdd" ? await validateAtddCoverageLedgers(root, config) : [],
     ...await validateCaseCatalogues(root, config),
     ...await validateContracts(root, config),
-    ...await validateTraceabilityMatrices(root, config),
+    ...await validateTraceabilityMatrices(root, config, phase),
     ...await validateDefinedIds(root, config),
-    ...await validateTraceability(root, config)
+    ...await validateTraceability(root, config, phase)
   ];
   const specsRoot = resolvePath(root, config, "specsDir");
   const scenarioFiles = await collectScenarioFiles(specsRoot);
@@ -4478,6 +4858,7 @@ async function validateProject(root, configResult) {
   const toolVersion = await resolveToolVersion();
   return {
     toolVersion,
+    phase,
     issues,
     counts: countIssues(issues),
     traceability: {
@@ -4512,15 +4893,15 @@ var REPORT_GUARDRAILS_MAX = 20;
 var REPORT_TEST_STRATEGY_SAMPLE_LIMIT = 20;
 var SC_TAG_RE6 = /^SC-\d{4}-\d{4}$/;
 async function createReportData(root, validation, configResult) {
-  const resolvedRoot = import_node_path17.default.resolve(root);
+  const resolvedRoot = import_node_path18.default.resolve(root);
   const resolved = configResult ?? await loadConfig(resolvedRoot);
   const config = resolved.config;
   const configPath = resolved.configPath;
   const specsRoot = resolvePath(resolvedRoot, config, "specsDir");
   const contractsRoot = resolvePath(resolvedRoot, config, "contractsDir");
-  const apiRoot = import_node_path17.default.join(contractsRoot, "api");
-  const uiRoot = import_node_path17.default.join(contractsRoot, "ui");
-  const dbRoot = import_node_path17.default.join(contractsRoot, "db");
+  const apiRoot = import_node_path18.default.join(contractsRoot, "api");
+  const uiRoot = import_node_path18.default.join(contractsRoot, "ui");
+  const dbRoot = import_node_path18.default.join(contractsRoot, "db");
   const srcRoot = resolvePath(resolvedRoot, config, "srcDir");
   const testsRoot = resolvePath(resolvedRoot, config, "testsDir");
   const specFiles = await collectSpecFiles(specsRoot);
@@ -5174,7 +5555,7 @@ async function collectSpecContractRefs(specFiles, contractIdList) {
     idToSpecs.set(contractId, /* @__PURE__ */ new Set());
   }
   for (const file of specFiles) {
-    const text = await (0, import_promises18.readFile)(file, "utf-8");
+    const text = await (0, import_promises19.readFile)(file, "utf-8");
     const parsed = parseSpec(text, file);
     const specKey = parsed.specId;
     if (!specKey) {
@@ -5218,7 +5599,7 @@ async function collectIds(files) {
     THEMA: /* @__PURE__ */ new Set()
   };
   for (const file of files) {
-    const text = await (0, import_promises18.readFile)(file, "utf-8");
+    const text = await (0, import_promises19.readFile)(file, "utf-8");
     for (const prefix of ID_PREFIXES2) {
       const ids = extractIds(text, prefix);
       ids.forEach((id) => result[prefix].add(id));
@@ -5239,7 +5620,7 @@ async function collectIds(files) {
 async function collectUpstreamIds(files) {
   const ids = /* @__PURE__ */ new Set();
   for (const file of files) {
-    const text = await (0, import_promises18.readFile)(file, "utf-8");
+    const text = await (0, import_promises19.readFile)(file, "utf-8");
     extractAllIds(text).forEach((id) => ids.add(id));
   }
   return ids;
@@ -5260,7 +5641,7 @@ async function evaluateTraceability(upstreamIds, srcRoot, testsRoot) {
   }
   const pattern = buildIdPattern2(Array.from(upstreamIds));
   for (const file of targetFiles) {
-    const text = await (0, import_promises18.readFile)(file, "utf-8");
+    const text = await (0, import_promises19.readFile)(file, "utf-8");
     if (pattern.test(text)) {
       return true;
     }
@@ -5381,7 +5762,7 @@ function normalizeScSources(root, sources) {
 async function countScenarios(scenarioFiles) {
   let total = 0;
   for (const file of scenarioFiles) {
-    const text = await (0, import_promises18.readFile)(file, "utf-8");
+    const text = await (0, import_promises19.readFile)(file, "utf-8");
     const { document, errors } = parseScenarioDocument(text, file);
     if (!document || errors.length > 0) {
       continue;
@@ -5412,7 +5793,7 @@ async function collectTestStrategy(scenarioFiles, root, config, limit) {
   let totalScenarios = 0;
   let e2eCount = 0;
   for (const file of scenarioFiles) {
-    const text = await (0, import_promises18.readFile)(file, "utf-8");
+    const text = await (0, import_promises19.readFile)(file, "utf-8");
     const { document, errors } = parseScenarioDocument(text, file);
     if (!document || errors.length > 0) {
       continue;