cleargate 0.12.0 → 0.13.0

package/dist/lib/lifecycle-reconcile.cjs

@@ -37,11 +37,13 @@ __export(lifecycle_reconcile_exports, {
   parseCommitMessage: () => parseCommitMessage,
   reconcileCrossSprintOrphans: () => reconcileCrossSprintOrphans,
   reconcileDecomposition: () => reconcileDecomposition,
-  reconcileLifecycle: () => reconcileLifecycle
+  reconcileLifecycle: () => reconcileLifecycle,
+  rollUpParentStatus: () => rollUpParentStatus,
+  walkActiveParents: () => walkActiveParents
 });
 module.exports = __toCommonJS(lifecycle_reconcile_exports);
-var fs = __toESM(require("fs"), 1);
-var path = __toESM(require("path"), 1);
+var fs2 = __toESM(require("fs"), 1);
+var path2 = __toESM(require("path"), 1);
 var import_node_child_process = require("child_process");
 
 // src/wiki/parse-frontmatter.ts
@@ -83,25 +85,305 @@ function parseFrontmatter(raw) {
   return { fm: parsed, body };
 }
 
+// src/lib/parent-rollup.ts
+var fs = __toESM(require("fs"), 1);
+var path = __toESM(require("path"), 1);
+function readFm(filePath) {
+  try {
+    const raw = fs.readFileSync(filePath, "utf8");
+    const { fm } = parseFrontmatter(raw);
+    return fm;
+  } catch {
+    return null;
+  }
+}
+function extractId(fm, filePath) {
+  for (const key of [
+    "story_id",
+    "epic_id",
+    "sprint_id",
+    "bug_id",
+    "cr_id",
+    "initiative_id",
+    "hotfix_id"
+  ]) {
+    const val = fm[key];
+    if (typeof val === "string" && val.trim() !== "") return val.trim();
+  }
+  const stem = path.basename(filePath, ".md");
+  return stem.split("_")[0] ?? stem;
+}
+function enumerateChildren(parentId, deliveryRoot, archiveRoot, fmCache) {
+  const pendingSyncDir = path.join(deliveryRoot, "pending-sync");
+  const results = [];
+  const pools = [];
+  if (fs.existsSync(archiveRoot)) pools.push(archiveRoot);
+  if (fs.existsSync(pendingSyncDir)) pools.push(pendingSyncDir);
+  for (const dir of pools) {
+    let entries;
+    try {
+      entries = fs.readdirSync(dir);
+    } catch {
+      entries = [];
+    }
+    for (const entry of entries) {
+      if (!entry.endsWith(".md")) continue;
+      const absPath = path.join(dir, entry);
+      let fm = fmCache.get(absPath);
+      if (fm === void 0) {
+        const parsed = readFm(absPath);
+        if (parsed === null) continue;
+        fm = parsed;
+        fmCache.set(absPath, fm);
+      }
+      const parentCleargateId = fm["parent_cleargate_id"];
+      const parentEpicRef = fm["parent_epic_ref"];
+      const isChild = typeof parentCleargateId === "string" && parentCleargateId.trim() === parentId || typeof parentEpicRef === "string" && parentEpicRef.trim() === parentId;
+      if (!isChild) continue;
+      const childId = extractId(fm, absPath);
+      const status = typeof fm["status"] === "string" ? fm["status"].trim() : "";
+      results.push({ id: childId, status });
+    }
+  }
+  return results;
+}
+async function rollUpParentStatusInternal(parentFilePath, opts, visited, fmCache) {
+  const { deliveryRoot, archiveRoot } = opts;
+  let fm = fmCache.get(parentFilePath);
+  if (fm === void 0) {
+    const raw = readFm(parentFilePath);
+    if (raw === null) {
+      throw new Error(`parent-rollup: cannot read frontmatter from ${parentFilePath}`);
+    }
+    fm = raw;
+    fmCache.set(parentFilePath, fm);
+  }
+  const parentId = extractId(fm, parentFilePath);
+  const currentStatus = typeof fm["status"] === "string" ? fm["status"].trim() : "";
+  if (ARTIFACT_TERMINAL_STATUSES.has(currentStatus)) {
+    return {
+      parent_id: parentId,
+      parent_path: parentFilePath,
+      current_status: currentStatus,
+      proposed_status: null,
+      coverage: "full",
+      terminal_children: [],
+      pending_children: [],
+      verdict: "no-op"
+    };
+  }
+  if (visited.has(parentId)) {
+    throw new Error(`parent-rollup: sub_epics cycle detected at ${parentId}`);
+  }
+  visited.add(parentId);
+  const subEpicsField = fm["sub_epics"];
+  const subEpics = Array.isArray(subEpicsField) && subEpicsField.length > 0 ? subEpicsField.filter((s) => typeof s === "string") : [];
+  if (subEpics.length > 0) {
+    const pendingSyncDir = path.join(deliveryRoot, "pending-sync");
+    const terminalSubEpics = [];
+    const pendingSubEpics = [];
+    for (const subEpicId of subEpics) {
+      let subEpicPath = null;
+      const candidateDirs = [pendingSyncDir, archiveRoot];
+      for (const dir of candidateDirs) {
+        if (!fs.existsSync(dir)) continue;
+        let entries;
+        try {
+          entries = fs.readdirSync(dir);
+        } catch {
+          entries = [];
+        }
+        for (const entry of entries) {
+          if (!entry.endsWith(".md")) continue;
+          const absPath = path.join(dir, entry);
+          let subFm2 = fmCache.get(absPath);
+          if (subFm2 === void 0) {
+            const parsed = readFm(absPath);
+            if (parsed === null) continue;
+            subFm2 = parsed;
+            fmCache.set(absPath, subFm2);
+          }
+          const entryId = extractId(subFm2, absPath);
+          if (entryId === subEpicId) {
+            subEpicPath = absPath;
+            break;
+          }
+        }
+        if (subEpicPath !== null) break;
+      }
+      if (subEpicPath === null) {
+        pendingSubEpics.push(subEpicId);
+        continue;
+      }
+      let subFm = fmCache.get(subEpicPath);
+      if (subFm === void 0) {
+        const parsed = readFm(subEpicPath);
+        if (parsed === null) {
+          pendingSubEpics.push(subEpicId);
+          continue;
+        }
+        subFm = parsed;
+        fmCache.set(subEpicPath, subFm);
+      }
+      const subStatus = typeof subFm["status"] === "string" ? subFm["status"].trim() : "";
+      if (subStatus === "DEFERRED") {
+        continue;
+      }
+      if (ARTIFACT_TERMINAL_STATUSES.has(subStatus)) {
+        terminalSubEpics.push(subEpicId);
+        continue;
+      }
+      const visitedSnapshot = new Set(visited);
+      const subResult = await rollUpParentStatusInternal(
+        subEpicPath,
+        opts,
+        visitedSnapshot,
+        fmCache
+      );
+      if (subResult.verdict === "auto-flip" || subResult.verdict === "no-op") {
+        terminalSubEpics.push(subEpicId);
+      } else {
+        pendingSubEpics.push(subEpicId);
+      }
+    }
+    visited.delete(parentId);
+    const total2 = terminalSubEpics.length + pendingSubEpics.length;
+    if (total2 === 0) {
+      return {
+        parent_id: parentId,
+        parent_path: parentFilePath,
+        current_status: currentStatus,
+        proposed_status: null,
+        coverage: "zero",
+        terminal_children: [],
+        pending_children: [],
+        verdict: "halt-zero-children",
+        halt_reason: `${parentId}: 0 children drafted; not reconcilable \u2014 decompose or abandon`
+      };
+    }
+    if (pendingSubEpics.length === 0) {
+      return {
+        parent_id: parentId,
+        parent_path: parentFilePath,
+        current_status: currentStatus,
+        proposed_status: "Completed",
+        coverage: "full",
+        terminal_children: terminalSubEpics,
+        pending_children: [],
+        verdict: "auto-flip"
+      };
+    }
+    return {
+      parent_id: parentId,
+      parent_path: parentFilePath,
+      current_status: currentStatus,
+      proposed_status: null,
+      coverage: "sub-epic-partial",
+      terminal_children: terminalSubEpics,
+      pending_children: pendingSubEpics,
+      verdict: "halt-partial",
+      halt_reason: `${parentId}: ${terminalSubEpics.length}/${total2} sub-epics terminal \u2014 pending: ${pendingSubEpics.join(", ")}`
+    };
+  }
+  const children = enumerateChildren(parentId, deliveryRoot, archiveRoot, fmCache);
+  visited.delete(parentId);
+  if (children.length === 0) {
+    return {
+      parent_id: parentId,
+      parent_path: parentFilePath,
+      current_status: currentStatus,
+      proposed_status: null,
+      coverage: "zero",
+      terminal_children: [],
+      pending_children: [],
+      verdict: "halt-zero-children",
+      halt_reason: `${parentId}: 0 children drafted; not reconcilable \u2014 decompose or abandon`
+    };
+  }
+  const terminalChildren = [];
+  const pendingChildren = [];
+  for (const child of children) {
+    if (ARTIFACT_TERMINAL_STATUSES.has(child.status)) {
+      terminalChildren.push(child.id);
+    } else {
+      pendingChildren.push(child.id);
+    }
+  }
+  const total = terminalChildren.length + pendingChildren.length;
+  if (pendingChildren.length === 0) {
+    return {
+      parent_id: parentId,
+      parent_path: parentFilePath,
+      current_status: currentStatus,
+      proposed_status: "Completed",
+      coverage: "full",
+      terminal_children: terminalChildren,
+      pending_children: [],
+      verdict: "auto-flip"
+    };
+  }
+  return {
+    parent_id: parentId,
+    parent_path: parentFilePath,
+    current_status: currentStatus,
+    proposed_status: null,
+    coverage: "partial",
+    terminal_children: terminalChildren,
+    pending_children: pendingChildren,
+    verdict: "halt-partial",
+    halt_reason: `${parentId}: ${terminalChildren.length}/${total} children terminal \u2014 pending: ${pendingChildren.join(", ")}`
+  };
+}
+async function rollUpParentStatus(parentFilePath, opts) {
+  const visited = /* @__PURE__ */ new Set();
+  const fmCache = /* @__PURE__ */ new Map();
+  return rollUpParentStatusInternal(parentFilePath, opts, visited, fmCache);
+}
+async function walkActiveParents(opts) {
+  const { deliveryRoot } = opts;
+  const pendingSyncDir = path.join(deliveryRoot, "pending-sync");
+  let entries;
+  try {
+    entries = fs.readdirSync(pendingSyncDir);
+  } catch {
+    return [];
+  }
+  const parentFiles = entries.filter(
+    (e) => e.endsWith(".md") && (e.startsWith("EPIC-") || e.startsWith("SPRINT-"))
+  );
+  const results = [];
+  const fmCache = /* @__PURE__ */ new Map();
+  for (const entry of parentFiles) {
+    const absPath = path.join(pendingSyncDir, entry);
+    try {
+      const visited = /* @__PURE__ */ new Set();
+      const result = await rollUpParentStatusInternal(absPath, opts, visited, fmCache);
+      results.push(result);
+    } catch (err) {
+      if (err instanceof Error && err.message.includes("sub_epics cycle detected")) {
+        throw err;
+      }
+    }
+  }
+  return results;
+}
+
 // src/lib/lifecycle-reconcile.ts
 var ARTIFACT_TERMINAL_STATUSES = /* @__PURE__ */ new Set([
-  "Done",
   "Completed",
-  "Verified",
   "Abandoned",
   "Closed",
-  "Resolved",
-  "Escalated",
-  "Parking Lot"
+  "Resolved"
 ]);
+var ARTIFACT_GATE_EXPECTED = ["Completed"];
 var VERB_STATUS_MAP = {
   feat: {
     types: ["STORY", "EPIC", "CR"],
-    expected: ["Done", "Completed"]
+    expected: [...ARTIFACT_GATE_EXPECTED]
   },
   fix: {
     types: ["BUG", "HOTFIX"],
-    expected: ["Verified", "Done", "Completed"]
+    expected: [...ARTIFACT_GATE_EXPECTED]
   }
 };
 var ID_PATTERN = /\b(STORY-\d{3}-\d{2}|(CR|BUG|EPIC|HOTFIX)-\d{3}|(PROPOSAL|PROP)-\d{3})\b/g;
@@ -152,10 +434,10 @@ function findArtifactFile(deliveryRoot, id) {
     { rel: "archive", inArchive: true }
   ];
   for (const { rel, inArchive } of dirs) {
-    const dir = path.join(deliveryRoot, rel);
+    const dir = path2.join(deliveryRoot, rel);
     let entries;
     try {
-      entries = fs.readdirSync(dir);
+      entries = fs2.readdirSync(dir);
     } catch {
       continue;
     }
@@ -163,7 +445,7 @@ function findArtifactFile(deliveryRoot, id) {
       (e) => (e.startsWith(prefix) || e === `${id}.md`) && e.endsWith(".md")
     );
     if (match) {
-      const absPath = path.join(dir, match);
+      const absPath = path2.join(dir, match);
       return { absPath, inArchive, relPath: `${rel}/${match}` };
     }
   }
@@ -172,7 +454,7 @@ function findArtifactFile(deliveryRoot, id) {
 function readArtifactStatus(absPath) {
   let raw;
   try {
-    raw = fs.readFileSync(absPath, "utf8");
+    raw = fs2.readFileSync(absPath, "utf8");
   } catch {
     return { status: null, carryOver: false };
   }
@@ -227,7 +509,7 @@ function reconcileLifecycle(opts) {
         if (carryOver) continue;
         let expectedStatuses;
         if (verb === "feat" && type === "BUG") {
-          expectedStatuses = ["Verified", "Done", "Completed"];
+          expectedStatuses = [...ARTIFACT_GATE_EXPECTED];
         } else if (!verbConfig.types.includes(type)) {
           continue;
         } else {
@@ -239,7 +521,7 @@ function reconcileLifecycle(opts) {
           cleanIds.add(id);
           idToItem.delete(id);
         } else if (!idToItem.has(id)) {
-          const expectedStr = expectedStatuses[0] ?? "Done";
+          const expectedStr = expectedStatuses[0] ?? "Completed";
           idToItem.set(id, {
             id,
             type,
@@ -270,13 +552,13 @@ function reconcileCrossSprintOrphans(opts) {
   const TERMINAL_STATE_JSON = /* @__PURE__ */ new Set(["Done", "Escalated", "Parking Lot"]);
   let activeSprintId = null;
   try {
-    activeSprintId = fs.readFileSync(path.join(sprintRunsRoot, ".active"), "utf8").trim();
+    activeSprintId = fs2.readFileSync(path2.join(sprintRunsRoot, ".active"), "utf8").trim();
   } catch {
   }
-  const pendingDir = path.join(deliveryRoot, "pending-sync");
+  const pendingDir = path2.join(deliveryRoot, "pending-sync");
   let pendingFiles;
   try {
-    pendingFiles = fs.readdirSync(pendingDir).filter(
+    pendingFiles = fs2.readdirSync(pendingDir).filter(
       (f) => f.endsWith(".md") && !f.startsWith(".")
     );
   } catch {
@@ -284,7 +566,7 @@ function reconcileCrossSprintOrphans(opts) {
   }
   const pendingMap = /* @__PURE__ */ new Map();
   for (const fileName of pendingFiles) {
-    const absPath = path.join(pendingDir, fileName);
+    const absPath = path2.join(pendingDir, fileName);
     const { status } = readArtifactStatus(absPath);
     if (status === null) continue;
     if (ARTIFACT_TERMINAL_STATUSES.has(status)) continue;
@@ -296,7 +578,7 @@ function reconcileCrossSprintOrphans(opts) {
     if (!type || type === "PROPOSAL") continue;
     pendingMap.set(id, {
       status,
-      filePath: path.join("pending-sync", fileName),
+      filePath: path2.join("pending-sync", fileName),
       type
     });
   }
@@ -305,10 +587,10 @@ function reconcileCrossSprintOrphans(opts) {
   }
   let sprintDirs;
   try {
-    sprintDirs = fs.readdirSync(sprintRunsRoot).filter((entry) => {
+    sprintDirs = fs2.readdirSync(sprintRunsRoot).filter((entry) => {
       if (entry.startsWith(".")) return false;
       try {
-        return fs.statSync(path.join(sprintRunsRoot, entry)).isDirectory();
+        return fs2.statSync(path2.join(sprintRunsRoot, entry)).isDirectory();
       } catch {
         return false;
       }
@@ -321,10 +603,10 @@ function reconcileCrossSprintOrphans(opts) {
   let clean = 0;
   for (const sprintDir of sprintDirs) {
     if (activeSprintId && sprintDir === activeSprintId) continue;
-    const stateFile = path.join(sprintRunsRoot, sprintDir, "state.json");
+    const stateFile = path2.join(sprintRunsRoot, sprintDir, "state.json");
     let stateJson;
     try {
-      const raw = fs.readFileSync(stateFile, "utf8");
+      const raw = fs2.readFileSync(stateFile, "utf8");
       stateJson = JSON.parse(raw);
     } catch {
       continue;
@@ -357,7 +639,7 @@ function reconcileDecomposition(opts) {
   const { sprintPlanPath, deliveryRoot } = opts;
   let raw;
   try {
-    raw = fs.readFileSync(sprintPlanPath, "utf8");
+    raw = fs2.readFileSync(sprintPlanPath, "utf8");
   } catch {
     return { missing: [], clean: 0 };
   }
@@ -369,11 +651,11 @@ function reconcileDecomposition(opts) {
   }
   const epics = Array.isArray(fm["epics"]) ? fm["epics"].map(String) : [];
   const proposals = Array.isArray(fm["proposals"]) ? fm["proposals"].map(String) : [];
-  const pendingDir = path.join(deliveryRoot, "pending-sync");
-  const archiveDir = path.join(deliveryRoot, "archive");
+  const pendingDir = path2.join(deliveryRoot, "pending-sync");
+  const archiveDir = path2.join(deliveryRoot, "archive");
   function listMdFiles(dir) {
     try {
-      return fs.readdirSync(dir).filter((f) => f.endsWith(".md"));
+      return fs2.readdirSync(dir).filter((f) => f.endsWith(".md"));
     } catch {
       return [];
     }
@@ -445,9 +727,9 @@ function findChildStories(epicId, pendingDir, pendingFiles, archiveDir, archiveF
     for (const f of files) {
       if (!f.startsWith(storyPrefix) && !f.startsWith("STORY-")) continue;
       if (!f.includes(storyPrefix)) continue;
-      const absPath = path.join(dir, f);
+      const absPath = path2.join(dir, f);
       try {
-        const raw = fs.readFileSync(absPath, "utf8");
+        const raw = fs2.readFileSync(absPath, "utf8");
         const { fm } = parseFrontmatter(raw);
         const parentRef = fm["parent_epic_ref"];
         if (parentRef === epicId) {
@@ -462,9 +744,9 @@ function findChildStories(epicId, pendingDir, pendingFiles, archiveDir, archiveF
 function findDecomposedEpic(proposalId, pendingDir, pendingFiles) {
   for (const f of pendingFiles) {
     if (!f.startsWith("EPIC-")) continue;
-    const absPath = path.join(pendingDir, f);
+    const absPath = path2.join(pendingDir, f);
     try {
-      const raw = fs.readFileSync(absPath, "utf8");
+      const raw = fs2.readFileSync(absPath, "utf8");
       const { fm } = parseFrontmatter(raw);
       const contextSource = fm["context_source"];
       if (typeof contextSource === "string" && contextSource.includes(proposalId)) {
@@ -492,6 +774,8 @@ function checkVerbMismatch(verb, type) {
   parseCommitMessage,
   reconcileCrossSprintOrphans,
   reconcileDecomposition,
-  reconcileLifecycle
+  reconcileLifecycle,
+  rollUpParentStatus,
+  walkActiveParents
 });
 //# sourceMappingURL=lifecycle-reconcile.cjs.map