@markmdev/pebble 0.1.21 → 0.1.23

package/dist/cli/index.js

@@ -658,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 = [];
@@ -1740,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();
@@ -1752,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 });
         }
@@ -1788,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");
         }
@@ -1796,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}`);
             }
@@ -1805,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 }
           }))));
         }
@@ -2995,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) {
@@ -3065,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 });