@markmdev/pebble 0.1.20 → 0.1.22

package/dist/cli/index.js

@@ -566,10 +566,12 @@ function getBlocking(issueId) {
     (issue) => issue.blockedBy.includes(issueId)
   );
 }
-function getChildren(epicId) {
+function getChildren(epicId, includeDeleted = false) {
   const events = readEvents();
   const state = computeState(events);
-  return Array.from(state.values()).filter((issue) => issue.parent === epicId);
+  return Array.from(state.values()).filter(
+    (issue) => issue.parent === epicId && (includeDeleted || !issue.deleted)
+  );
 }
 function getVerifications(issueId) {
   const events = readEvents();
@@ -656,6 +658,73 @@ function getAncestryChain(issueId, state) {
   }
   return chain;
 }
+function getAncestryBlocker(issueId, state) {
+  let current = state.get(issueId);
+  while (current?.parent) {
+    const parent = state.get(current.parent);
+    if (!parent) break;
+    const openBlockers = parent.blockedBy.map((id) => state.get(id)).filter((i) => i !== void 0 && i.status !== "closed" && !i.deleted);
+    if (openBlockers.length > 0) {
+      return { blockedAncestor: parent, blockers: openBlockers };
+    }
+    current = parent;
+  }
+  return null;
+}
+function claimWithCascade(issueId, pebbleDir) {
+  const events = readEvents();
+  const state = computeState(events);
+  const issue = state.get(issueId);
+  if (!issue) {
+    return { success: false, error: `Issue not found: ${issueId}` };
+  }
+  if (issue.deleted) {
+    return { success: false, error: `Cannot claim deleted issue: ${issueId}` };
+  }
+  if (issue.status === "closed") {
+    return { success: false, error: `Cannot claim closed issue: ${issueId}` };
+  }
+  const openBlockers = issue.blockedBy.map((id) => state.get(id)).filter((i) => i !== void 0 && i.status !== "closed" && !i.deleted);
+  if (openBlockers.length > 0) {
+    const blockerIds = openBlockers.map((b) => b.id).join(", ");
+    return {
+      success: false,
+      error: `Cannot claim blocked issue. Blocked by: ${blockerIds}`
+    };
+  }
+  const ancestryBlocker = getAncestryBlocker(issueId, state);
+  if (ancestryBlocker) {
+    const blockerIds = ancestryBlocker.blockers.map((b) => b.id).join(", ");
+    return {
+      success: false,
+      error: `Parent ${ancestryBlocker.blockedAncestor.id} is blocked by: ${blockerIds}`
+    };
+  }
+  const toClaim = [];
+  if (issue.status !== "in_progress") {
+    toClaim.push(issueId);
+  }
+  let current = issue;
+  while (current.parent) {
+    const parent = state.get(current.parent);
+    if (!parent) break;
+    if (parent.status === "open") {
+      toClaim.push(parent.id);
+    }
+    current = parent;
+  }
+  const timestamp = (/* @__PURE__ */ new Date()).toISOString();
+  for (const id of toClaim) {
+    const event = {
+      type: "update",
+      issueId: id,
+      timestamp,
+      data: { status: "in_progress" }
+    };
+    appendEvent(event, pebbleDir);
+  }
+  return { success: true, claimedIds: toClaim };
+}
 function getDescendants(issueId, state) {
   const issueState = state ?? getComputedState();
   const descendants = [];
@@ -1148,6 +1217,15 @@ function createCommand(program2) {
         }
       };
       appendEvent(event, pebbleDir);
+      if (parentId) {
+        const parentUpdateEvent = {
+          type: "update",
+          issueId: parentId,
+          timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+          data: {}
+        };
+        appendEvent(parentUpdateEvent, pebbleDir);
+      }
       if (blockedByIds.length > 0) {
         const depEvent = {
           type: "update",
@@ -1322,8 +1400,8 @@ function closeCommand(program2) {
             results.push({ id: resolvedId, success: false, error: `Issue is already closed: ${resolvedId}` });
             continue;
           }
-          if (issue.type === "epic" && hasOpenChildren(resolvedId)) {
-            results.push({ id: resolvedId, success: false, error: `Cannot close epic with open children: ${resolvedId}` });
+          if (hasOpenChildren(resolvedId)) {
+            results.push({ id: resolvedId, success: false, error: `Cannot close issue with open children: ${resolvedId}` });
             continue;
           }
           const timestamp = (/* @__PURE__ */ new Date()).toISOString();
@@ -1729,7 +1807,7 @@ function restoreCommand(program2) {
 
 // src/cli/commands/claim.ts
 function claimCommand(program2) {
-  program2.command("claim <ids...>").description("Claim issues (set status to in_progress). Supports multiple IDs.").action(async (ids) => {
+  program2.command("claim <ids...>").description("Claim issues (set status to in_progress). Cascades to open parent issues.").action(async (ids) => {
     const pretty = program2.opts().pretty ?? false;
     try {
       const pebbleDir = getOrCreatePebbleDir();
@@ -1741,35 +1819,20 @@ function claimCommand(program2) {
       for (const id of allIds) {
         try {
           const resolvedId = resolveId(id);
-          const issue = getIssue(resolvedId);
-          if (!issue) {
-            results.push({ id, success: false, error: `Issue not found: ${id}` });
-            continue;
-          }
-          if (issue.status === "in_progress") {
-            results.push({ id: resolvedId, success: true });
-            continue;
-          }
-          if (issue.status === "closed") {
-            results.push({ id: resolvedId, success: false, error: `Cannot claim closed issue: ${resolvedId}` });
-            continue;
-          }
-          if (hasOpenBlockersById(resolvedId)) {
-            const blockers = getOpenBlockers(resolvedId);
-            const blockerIds = blockers.map((b) => b.id).join(", ");
-            results.push({ id: resolvedId, success: false, error: `Cannot claim blocked issue. Blocked by: ${blockerIds}` });
-            continue;
+          const result = claimWithCascade(resolvedId, pebbleDir);
+          if (result.success) {
+            results.push({
+              id: resolvedId,
+              success: true,
+              claimedIds: result.claimedIds
+            });
+          } else {
+            results.push({
+              id: resolvedId,
+              success: false,
+              error: result.error
+            });
           }
-          const event = {
-            type: "update",
-            issueId: resolvedId,
-            timestamp: (/* @__PURE__ */ new Date()).toISOString(),
-            data: {
-              status: "in_progress"
-            }
-          };
-          appendEvent(event, pebbleDir);
-          results.push({ id: resolvedId, success: true });
         } catch (error) {
           results.push({ id, success: false, error: error.message });
         }
@@ -1777,7 +1840,20 @@ function claimCommand(program2) {
       if (allIds.length === 1) {
         const result = results[0];
         if (result.success) {
-          outputMutationSuccess(result.id, pretty);
+          if (pretty) {
+            const cascaded = result.claimedIds?.filter((cid) => cid !== result.id) ?? [];
+            if (cascaded.length > 0) {
+              console.log(`\u2713 ${result.id} (also claimed: ${cascaded.join(", ")})`);
+            } else {
+              console.log(`\u2713 ${result.id}`);
+            }
+          } else {
+            console.log(formatJson({
+              id: result.id,
+              success: true,
+              claimedIds: result.claimedIds
+            }));
+          }
         } else {
           throw new Error(result.error || "Unknown error");
         }
@@ -1785,7 +1861,12 @@ function claimCommand(program2) {
         if (pretty) {
           for (const result of results) {
             if (result.success) {
-              console.log(`\u2713 ${result.id}`);
+              const cascaded = result.claimedIds?.filter((cid) => cid !== result.id) ?? [];
+              if (cascaded.length > 0) {
+                console.log(`\u2713 ${result.id} (also claimed: ${cascaded.join(", ")})`);
+              } else {
+                console.log(`\u2713 ${result.id}`);
+              }
             } else {
               console.log(`\u2717 ${result.id}: ${result.error}`);
             }
@@ -1794,6 +1875,7 @@ function claimCommand(program2) {
           console.log(formatJson(results.map((r) => ({
             id: r.id,
             success: r.success,
+            ...r.claimedIds && { claimedIds: r.claimedIds },
             ...r.error && { error: r.error }
           }))));
         }
@@ -2805,6 +2887,15 @@ data: ${message}
             }
           };
           appendEvent(event, pebbleDir);
+          if (parent) {
+            const parentUpdateEvent = {
+              type: "update",
+              issueId: parent,
+              timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+              data: {}
+            };
+            appendEvent(parentUpdateEvent, pebbleDir);
+          }
           const issue = getIssue(issueId);
           const result = parentReopened ? { ...issue, _parentReopened: parentReopened } : issue;
           res.status(201).json(result);
@@ -2833,8 +2924,8 @@ data: ${message}
                 results.push({ id: issueId, success: true });
                 continue;
               }
-              if (issue.type === "epic" && hasOpenChildren(issueId)) {
-                results.push({ id: issueId, success: false, error: "Cannot close epic with open children" });
+              if (hasOpenChildren(issueId)) {
+                results.push({ id: issueId, success: false, error: "Cannot close issue with open children" });
                 continue;
               }
               const pendingVerifications = getVerifications(issueId).filter((v) => v.status !== "closed");
@@ -2975,11 +3066,47 @@ data: ${message}
             }
             updates.priority = priority;
           }
+          const cascadeClaim = [];
           if (status !== void 0) {
             if (!STATUSES.includes(status)) {
               res.status(400).json({ error: `Invalid status. Must be one of: ${STATUSES.join(", ")}` });
               return;
             }
+            if (status === "in_progress" && issue.status !== "in_progress") {
+              const state = isMultiWorktree() ? computeState(issueFiles.flatMap((f) => readEventsFromFile(f))) : getComputedState();
+              const openBlockers = issue.blockedBy.map((id) => state.get(id)).filter((i) => i !== void 0 && i.status !== "closed" && !i.deleted);
+              if (openBlockers.length > 0) {
+                const blockerIds = openBlockers.map((b) => b.id).join(", ");
+                res.status(400).json({
+                  error: `Cannot claim blocked issue. Blocked by: ${blockerIds}`
+                });
+                return;
+              }
+              const ancestryBlocker = getAncestryBlocker(issueId, state);
+              if (ancestryBlocker) {
+                const blockerIds = ancestryBlocker.blockers.map((b) => b.id).join(", ");
+                res.status(400).json({
+                  error: `Parent ${ancestryBlocker.blockedAncestor.id} is blocked by: ${blockerIds}`
+                });
+                return;
+              }
+              let current = issue;
+              while (current.parent) {
+                const parent2 = state.get(current.parent);
+                if (!parent2) break;
+                if (parent2.status === "open") {
+                  let parentTargetFile = targetFile;
+                  if (isMultiWorktree()) {
+                    const parentFound = findIssueInSources(parent2.id, issueFiles);
+                    if (parentFound) {
+                      parentTargetFile = parentFound.targetFile;
+                    }
+                  }
+                  cascadeClaim.push({ id: parent2.id, targetFile: parentTargetFile });
+                }
+                current = parent2;
+              }
+            }
             updates.status = status;
           }
           if (description !== void 0) {
@@ -3045,11 +3172,32 @@ data: ${message}
             data: updates
           };
           appendEventToFile(event, targetFile);
+          const cascadeClaimedIds = [];
+          for (const { id, targetFile: parentTargetFile } of cascadeClaim) {
+            const cascadeEvent = {
+              type: "update",
+              issueId: id,
+              timestamp,
+              data: { status: "in_progress" }
+            };
+            appendEventToFile(cascadeEvent, parentTargetFile);
+            cascadeClaimedIds.push(id);
+          }
           if (isMultiWorktree()) {
             const updated = findIssueInSources(issueId, issueFiles);
-            res.json(updated?.issue || { ...issue, ...updates, updatedAt: timestamp });
+            const baseIssue = updated?.issue || { ...issue, ...updates, updatedAt: timestamp };
+            if (cascadeClaimedIds.length > 0) {
+              res.json({ ...baseIssue, _cascadeClaimed: cascadeClaimedIds });
+            } else {
+              res.json(baseIssue);
+            }
           } else {
-            res.json(getIssue(issueId));
+            const updatedIssue = getIssue(issueId);
+            if (cascadeClaimedIds.length > 0) {
+              res.json({ ...updatedIssue, _cascadeClaimed: cascadeClaimedIds });
+            } else {
+              res.json(updatedIssue);
+            }
           }
         } catch (error) {
           res.status(500).json({ error: error.message });
@@ -3084,8 +3232,8 @@ data: ${message}
             res.status(400).json({ error: "Issue is already closed" });
             return;
           }
-          if (!isMultiWorktree() && issue.type === "epic" && hasOpenChildren(issueId)) {
-            res.status(400).json({ error: "Cannot close epic with open children" });
+          if (!isMultiWorktree() && hasOpenChildren(issueId)) {
+            res.status(400).json({ error: "Cannot close issue with open children" });
             return;
           }
           const { reason } = req.body;
@@ -3898,6 +4046,21 @@ function formatInProgressPretty(issues) {
   }
   return lines.join("\n");
 }
+function formatClosedIssuesPretty(issues) {
+  if (issues.length === 0) return "";
+  const lines = [];
+  lines.push(`## Recently Closed (${issues.length})`);
+  lines.push("");
+  for (const issue of issues) {
+    lines.push(`\u2713 ${issue.id}: ${issue.title} [${issue.type}]`);
+    lines.push(`  Closed: ${formatRelativeTime(issue.closedAt)}${issue.lastSource ? ` | Source: ${issue.lastSource}` : ""}`);
+    if (issue.parent) {
+      lines.push(`  Parent: ${issue.parent.title}`);
+    }
+    lines.push("");
+  }
+  return lines.join("\n");
+}
 function formatSummaryPretty(summaries, sectionHeader) {
   if (summaries.length === 0) {
     return "No epics found.";
@@ -4012,6 +4175,27 @@ function summaryCommand(program2) {
       const limitedClosed = limit > 0 ? closedEpics.slice(0, limit) : closedEpics;
       const openSummaries = limitedOpen.map(buildSummary);
       const closedSummaries = limitedClosed.map(buildSummary);
+      let closedIssues = getIssues({ status: "closed" });
+      closedIssues.sort(
+        (a, b) => new Date(b.updatedAt).getTime() - new Date(a.updatedAt).getTime()
+      );
+      closedIssues = closedIssues.slice(0, 20);
+      const recentlyClosedSummaries = closedIssues.map((issue) => {
+        const summary = {
+          id: issue.id,
+          title: issue.title,
+          type: issue.type,
+          closedAt: issue.updatedAt,
+          lastSource: issue.lastSource
+        };
+        if (issue.parent) {
+          const parentIssue = getIssue(issue.parent, true);
+          if (parentIssue) {
+            summary.parent = { id: parentIssue.id, title: parentIssue.title };
+          }
+        }
+        return summary;
+      });
       if (pretty) {
         const output = [];
         const inProgressOutput = formatInProgressPretty(inProgressSummaries);
@@ -4026,12 +4210,16 @@ function summaryCommand(program2) {
           if (output.length > 0) output.push("");
           output.push(formatSummaryPretty(closedSummaries, "Recently Closed Epics (last 72h)"));
         }
+        if (recentlyClosedSummaries.length > 0) {
+          if (output.length > 0) output.push("");
+          output.push(formatClosedIssuesPretty(recentlyClosedSummaries));
+        }
         if (output.length === 0) {
           output.push("No issues in progress and no epics found.");
         }
         console.log(output.join("\n"));
       } else {
-        console.log(formatJson({ inProgress: inProgressSummaries, open: openSummaries, closed: closedSummaries }));
+        console.log(formatJson({ inProgress: inProgressSummaries, open: openSummaries, closed: closedSummaries, recentlyClosed: recentlyClosedSummaries }));
       }
     } catch (error) {
       outputError(error, pretty);