@markmdev/pebble 0.1.16 → 0.1.17

package/dist/cli/index.js

@@ -16,7 +16,7 @@ import { dirname as dirname2, join as join3 } from "path";
 var ISSUE_TYPES = ["task", "bug", "epic", "verification"];
 var PRIORITIES = [0, 1, 2, 3, 4];
 var STATUSES = ["open", "in_progress", "blocked", "pending_verification", "closed"];
-var EVENT_TYPES = ["create", "update", "close", "reopen", "comment"];
+var EVENT_TYPES = ["create", "update", "close", "reopen", "comment", "delete", "restore"];
 var PRIORITY_LABELS = {
   0: "critical",
   1: "high",
@@ -360,14 +360,37 @@ function computeState(events) {
         }
         break;
       }
+      case "delete": {
+        const issue = issues.get(event.issueId);
+        if (issue) {
+          issue.deleted = true;
+          issue.deletedAt = event.timestamp;
+          issue.updatedAt = event.timestamp;
+          if (event.source) issue.lastSource = event.source;
+        }
+        break;
+      }
+      case "restore": {
+        const issue = issues.get(event.issueId);
+        if (issue) {
+          issue.deleted = false;
+          issue.deletedAt = void 0;
+          issue.updatedAt = event.timestamp;
+          if (event.source) issue.lastSource = event.source;
+        }
+        break;
+      }
     }
   }
   return issues;
 }
-function getIssues(filters) {
+function getIssues(filters, includeDeleted = false) {
   const events = readEvents();
   const state = computeState(events);
   let issues = Array.from(state.values());
+  if (!includeDeleted) {
+    issues = issues.filter((i) => !i.deleted);
+  }
   if (filters) {
     if (filters.status !== void 0) {
       issues = issues.filter((i) => i.status === filters.status);
@@ -384,10 +407,14 @@ function getIssues(filters) {
   }
   return issues;
 }
-function getIssue(id) {
+function getIssue(id, includeDeleted = false) {
   const events = readEvents();
   const state = computeState(events);
-  return state.get(id);
+  const issue = state.get(id);
+  if (issue && issue.deleted && !includeDeleted) {
+    return void 0;
+  }
+  return issue;
 }
 function resolveId(partial) {
   const events = readEvents();
@@ -430,6 +457,9 @@ function getReady() {
   const state = computeState(events);
   const issues = Array.from(state.values());
   return issues.filter((issue) => {
+    if (issue.deleted) {
+      return false;
+    }
     if (issue.status === "closed" || issue.status === "pending_verification") {
       return false;
     }
@@ -453,6 +483,9 @@ function getBlocked() {
   const state = computeState(events);
   const issues = Array.from(state.values());
   return issues.filter((issue) => {
+    if (issue.deleted) {
+      return false;
+    }
     if (issue.status === "closed") {
       return false;
     }
@@ -616,6 +649,20 @@ function getAncestryChain(issueId, state) {
   }
   return chain;
 }
+function getDescendants(issueId, state) {
+  const issueState = state ?? getComputedState();
+  const descendants = [];
+  function collectDescendants(parentId) {
+    for (const issue of issueState.values()) {
+      if (issue.parent === parentId && !issue.deleted) {
+        descendants.push(issue);
+        collectDescendants(issue.id);
+      }
+    }
+  }
+  collectDescendants(issueId);
+  return descendants;
+}
 
 // src/shared/time.ts
 import { formatDistanceToNow, parseISO } from "date-fns";
@@ -931,7 +978,7 @@ function formatIssueListVerbose(issues, sectionHeader) {
     lines.push(`${issue.id}: ${issue.title}`);
     lines.push(`  Type: ${formatType(issue.type)} | Priority: P${issue.priority} | Created: ${formatRelativeTime(issue.createdAt)}`);
     if (ancestry.length > 0) {
-      const chain = [...ancestry].reverse().map((a) => a.id).join(" > ");
+      const chain = [...ancestry].reverse().map((a) => a.title).join(" \u2192 ");
       lines.push(`  Ancestry: ${chain}`);
     }
     if (blocking.length > 0) {
@@ -1412,6 +1459,220 @@ function reopenCommand(program2) {
   });
 }
 
+// src/cli/commands/delete.ts
+function collectReferenceCleanup(deletedId, deletedIds, state, updates) {
+  for (const [id, issue] of state) {
+    if (deletedIds.has(id)) continue;
+    if (issue.deleted) continue;
+    let entry = updates.get(id);
+    const currentBlockedBy = entry?.blockedBy ?? issue.blockedBy;
+    if (currentBlockedBy.includes(deletedId)) {
+      if (!entry) {
+        entry = {};
+        updates.set(id, entry);
+      }
+      entry.blockedBy = currentBlockedBy.filter((bid) => bid !== deletedId);
+    }
+    const currentRelatedTo = entry?.relatedTo ?? issue.relatedTo;
+    if (currentRelatedTo.includes(deletedId)) {
+      if (!entry) {
+        entry = {};
+        updates.set(id, entry);
+      }
+      entry.relatedTo = currentRelatedTo.filter((rid) => rid !== deletedId);
+    }
+    if (issue.parent === deletedId) {
+      if (!entry) {
+        entry = {};
+        updates.set(id, entry);
+      }
+      entry.parent = "";
+    }
+  }
+}
+function emitReferenceCleanup(updates, pebbleDir, timestamp) {
+  for (const [id, data] of updates) {
+    if (Object.keys(data).length > 0) {
+      const updateEvent = {
+        type: "update",
+        issueId: id,
+        timestamp,
+        data
+      };
+      appendEvent(updateEvent, pebbleDir);
+    }
+  }
+}
+function deleteCommand(program2) {
+  program2.command("delete <ids...>").description("Delete issues (soft delete). Epics cascade-delete their children.").option("-r, --reason <reason>", "Reason for deleting").action(async (ids, options) => {
+    const pretty = program2.opts().pretty ?? false;
+    try {
+      const pebbleDir = getOrCreatePebbleDir();
+      const state = getComputedState();
+      const allIds = ids.flatMap((id) => id.split(",").map((s) => s.trim()).filter(Boolean));
+      if (allIds.length === 0) {
+        throw new Error("No issue IDs provided");
+      }
+      const results = [];
+      const toDelete = [];
+      const alreadyQueued = /* @__PURE__ */ new Set();
+      for (const id of allIds) {
+        try {
+          const resolvedId = resolveId(id);
+          const issue = state.get(resolvedId);
+          if (!issue) {
+            results.push({ id, success: false, error: `Issue not found: ${id}` });
+            continue;
+          }
+          if (issue.deleted) {
+            results.push({ id: resolvedId, success: false, error: `Issue is already deleted: ${resolvedId}` });
+            continue;
+          }
+          if (!alreadyQueued.has(resolvedId)) {
+            toDelete.push({ id: resolvedId, cascade: false });
+            alreadyQueued.add(resolvedId);
+          }
+          const descendants = getDescendants(resolvedId, state);
+          for (const desc of descendants) {
+            if (!alreadyQueued.has(desc.id) && !desc.deleted) {
+              toDelete.push({ id: desc.id, cascade: true });
+              alreadyQueued.add(desc.id);
+            }
+          }
+          const verifications = getVerifications(resolvedId);
+          for (const v of verifications) {
+            if (!alreadyQueued.has(v.id) && !v.deleted) {
+              toDelete.push({ id: v.id, cascade: true });
+              alreadyQueued.add(v.id);
+            }
+          }
+        } catch (error) {
+          results.push({ id, success: false, error: error.message });
+        }
+      }
+      const timestamp = (/* @__PURE__ */ new Date()).toISOString();
+      const deletedIds = new Set(toDelete.map((d) => d.id));
+      const referenceUpdates = /* @__PURE__ */ new Map();
+      for (const { id } of toDelete) {
+        collectReferenceCleanup(id, deletedIds, state, referenceUpdates);
+      }
+      emitReferenceCleanup(referenceUpdates, pebbleDir, timestamp);
+      for (const { id, cascade } of toDelete) {
+        const issue = state.get(id);
+        if (!issue) continue;
+        const deleteEvent = {
+          type: "delete",
+          issueId: id,
+          timestamp,
+          data: {
+            reason: options.reason,
+            cascade: cascade || void 0,
+            previousStatus: issue.status
+          }
+        };
+        appendEvent(deleteEvent, pebbleDir);
+        results.push({ id, success: true, cascade: cascade || void 0 });
+      }
+      if (pretty) {
+        const primary = results.filter((r) => r.success && !r.cascade);
+        const cascaded = results.filter((r) => r.success && r.cascade);
+        const failed = results.filter((r) => !r.success);
+        for (const result of primary) {
+          console.log(`\u{1F5D1}\uFE0F  ${result.id} deleted`);
+        }
+        for (const result of cascaded) {
+          console.log(`  \u2514\u2500 ${result.id} deleted (cascade)`);
+        }
+        for (const result of failed) {
+          console.log(`\u2717 ${result.id}: ${result.error}`);
+        }
+      } else {
+        console.log(formatJson({
+          deleted: results.filter((r) => r.success).map((r) => ({ id: r.id, cascade: r.cascade ?? false })),
+          ...results.some((r) => !r.success) && {
+            errors: results.filter((r) => !r.success).map((r) => ({ id: r.id, error: r.error }))
+          }
+        }));
+      }
+    } catch (error) {
+      outputError(error, pretty);
+    }
+  });
+}
+
+// src/cli/commands/restore.ts
+function restoreCommand(program2) {
+  program2.command("restore <ids...>").description("Restore deleted issues").option("-r, --reason <reason>", "Reason for restoring").action(async (ids, options) => {
+    const pretty = program2.opts().pretty ?? false;
+    try {
+      const pebbleDir = getOrCreatePebbleDir();
+      const allIds = ids.flatMap((id) => id.split(",").map((s) => s.trim()).filter(Boolean));
+      if (allIds.length === 0) {
+        throw new Error("No issue IDs provided");
+      }
+      const results = [];
+      const timestamp = (/* @__PURE__ */ new Date()).toISOString();
+      for (const id of allIds) {
+        try {
+          const resolvedId = resolveId(id);
+          const issue = getIssue(resolvedId, true);
+          if (!issue) {
+            results.push({ id, success: false, error: `Issue not found: ${id}` });
+            continue;
+          }
+          if (!issue.deleted) {
+            results.push({ id: resolvedId, success: false, error: `Issue is not deleted: ${resolvedId}` });
+            continue;
+          }
+          const restoreEvent = {
+            type: "restore",
+            issueId: resolvedId,
+            timestamp,
+            data: {
+              reason: options.reason
+            }
+          };
+          appendEvent(restoreEvent, pebbleDir);
+          results.push({ id: resolvedId, success: true });
+        } catch (error) {
+          results.push({ id, success: false, error: error.message });
+        }
+      }
+      if (allIds.length === 1) {
+        const result = results[0];
+        if (result.success) {
+          if (pretty) {
+            console.log(`\u21A9\uFE0F  ${result.id} restored`);
+          } else {
+            console.log(formatJson({ id: result.id, success: true }));
+          }
+        } else {
+          throw new Error(result.error || "Unknown error");
+        }
+      } else {
+        if (pretty) {
+          for (const result of results) {
+            if (result.success) {
+              console.log(`\u21A9\uFE0F  ${result.id} restored`);
+            } else {
+              console.log(`\u2717 ${result.id}: ${result.error}`);
+            }
+          }
+        } else {
+          console.log(formatJson({
+            restored: results.filter((r) => r.success).map((r) => r.id),
+            ...results.some((r) => !r.success) && {
+              errors: results.filter((r) => !r.success).map((r) => ({ id: r.id, error: r.error }))
+            }
+          }));
+        }
+      }
+    } catch (error) {
+      outputError(error, pretty);
+    }
+  });
+}
+
 // 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) => {
@@ -2894,6 +3155,151 @@ data: ${message}
           res.status(500).json({ error: error.message });
         }
       });
+      app.post("/api/issues/:id/delete", (req, res) => {
+        try {
+          let issue;
+          let issueId;
+          let targetFile;
+          if (isMultiWorktree()) {
+            const found = findIssueInSources(req.params.id, issueFiles);
+            if (!found) {
+              res.status(404).json({ error: `Issue not found: ${req.params.id}` });
+              return;
+            }
+            issue = found.issue;
+            issueId = issue.id;
+            targetFile = found.targetFile;
+          } else {
+            const pebbleDir = getOrCreatePebbleDir();
+            issueId = resolveId(req.params.id);
+            const localIssue = getIssue(issueId);
+            if (!localIssue) {
+              res.status(404).json({ error: `Issue not found: ${req.params.id}` });
+              return;
+            }
+            issue = localIssue;
+            targetFile = path3.join(pebbleDir, "issues.jsonl");
+          }
+          if (issue.deleted) {
+            res.status(400).json({ error: "Issue is already deleted" });
+            return;
+          }
+          const { reason } = req.body;
+          const timestamp = (/* @__PURE__ */ new Date()).toISOString();
+          const state = getComputedState();
+          const toDelete = [];
+          const alreadyQueued = /* @__PURE__ */ new Set();
+          toDelete.push({ id: issueId, cascade: false });
+          alreadyQueued.add(issueId);
+          const descendants = getDescendants(issueId, state);
+          for (const desc of descendants) {
+            if (!alreadyQueued.has(desc.id) && !desc.deleted) {
+              toDelete.push({ id: desc.id, cascade: true });
+              alreadyQueued.add(desc.id);
+            }
+          }
+          const verifications = getVerifications(issueId);
+          for (const v of verifications) {
+            if (!alreadyQueued.has(v.id) && !v.deleted) {
+              toDelete.push({ id: v.id, cascade: true });
+              alreadyQueued.add(v.id);
+            }
+          }
+          const cleanupReferences = (deletedId) => {
+            for (const [id, iss] of state) {
+              if (id === deletedId || iss.deleted) continue;
+              const updates = {};
+              if (iss.blockedBy.includes(deletedId)) {
+                updates.blockedBy = iss.blockedBy.filter((bid) => bid !== deletedId);
+              }
+              if (iss.relatedTo.includes(deletedId)) {
+                updates.relatedTo = iss.relatedTo.filter((rid) => rid !== deletedId);
+              }
+              if (iss.parent === deletedId) {
+                updates.parent = "";
+              }
+              if (Object.keys(updates).length > 0) {
+                const updateEvent = {
+                  type: "update",
+                  issueId: id,
+                  timestamp,
+                  data: updates
+                };
+                appendEventToFile(updateEvent, targetFile);
+              }
+            }
+          };
+          for (const { id, cascade } of toDelete) {
+            const iss = state.get(id);
+            if (!iss) continue;
+            cleanupReferences(id);
+            const deleteEvent = {
+              type: "delete",
+              issueId: id,
+              timestamp,
+              data: {
+                reason,
+                cascade: cascade || void 0,
+                previousStatus: iss.status
+              }
+            };
+            appendEventToFile(deleteEvent, targetFile);
+          }
+          res.json({
+            deleted: toDelete
+          });
+        } catch (error) {
+          res.status(500).json({ error: error.message });
+        }
+      });
+      app.post("/api/issues/:id/restore", (req, res) => {
+        try {
+          let issue;
+          let issueId;
+          let targetFile;
+          if (isMultiWorktree()) {
+            const found = findIssueInSources(req.params.id, issueFiles);
+            if (!found) {
+              res.status(404).json({ error: `Issue not found: ${req.params.id}` });
+              return;
+            }
+            issue = found.issue;
+            issueId = issue.id;
+            targetFile = found.targetFile;
+          } else {
+            const pebbleDir = getOrCreatePebbleDir();
+            issueId = resolveId(req.params.id);
+            const localIssue = getIssue(issueId);
+            if (!localIssue) {
+              res.status(404).json({ error: `Issue not found: ${req.params.id}` });
+              return;
+            }
+            issue = localIssue;
+            targetFile = path3.join(pebbleDir, "issues.jsonl");
+          }
+          if (!issue.deleted) {
+            res.status(400).json({ error: "Issue is not deleted" });
+            return;
+          }
+          const { reason } = req.body;
+          const timestamp = (/* @__PURE__ */ new Date()).toISOString();
+          const event = {
+            type: "restore",
+            issueId,
+            timestamp,
+            data: { reason }
+          };
+          appendEventToFile(event, targetFile);
+          if (isMultiWorktree()) {
+            const updated = findIssueInSources(issueId, issueFiles);
+            res.json(updated?.issue || { ...issue, deleted: false, deletedAt: void 0, updatedAt: timestamp });
+          } else {
+            res.json(getIssue(issueId));
+          }
+        } catch (error) {
+          res.status(500).json({ error: error.message });
+        }
+      });
       app.post("/api/issues/:id/comments", (req, res) => {
         try {
           let issue;
@@ -3401,6 +3807,35 @@ function countVerifications(epicId) {
   }
   return { total, done };
 }
+function getIssueComments(issueId) {
+  const events = readEvents();
+  return events.filter((e) => e.type === "comment" && e.issueId === issueId).sort((a, b) => new Date(b.timestamp).getTime() - new Date(a.timestamp).getTime()).map((e) => ({ text: e.data.text, timestamp: e.timestamp, source: e.source }));
+}
+function formatInProgressPretty(issues) {
+  if (issues.length === 0) return "";
+  const lines = [];
+  lines.push(`## In Progress (${issues.length})`);
+  lines.push("");
+  for (const issue of issues) {
+    lines.push(`\u25B6 ${issue.id}: ${issue.title} [${issue.type}]`);
+    lines.push(`  Updated: ${formatRelativeTime(issue.updatedAt)}${issue.lastSource ? ` | Source: ${issue.lastSource}` : ""}`);
+    if (issue.parent) {
+      lines.push(`  Parent: ${issue.parent.title}`);
+    }
+    if (issue.comments.length > 0) {
+      const recentComments = issue.comments.slice(0, 3);
+      for (const comment of recentComments) {
+        const truncated = comment.text.length > 100 ? comment.text.substring(0, 100) + "..." : comment.text;
+        lines.push(`    \u2022 ${formatRelativeTime(comment.timestamp)}: ${truncated.replace(/\n/g, " ")}`);
+      }
+      if (issue.comments.length > 3) {
+        lines.push(`    (${issue.comments.length - 3} more comment${issue.comments.length - 3 === 1 ? "" : "s"})`);
+      }
+    }
+    lines.push("");
+  }
+  return lines.join("\n");
+}
 function formatSummaryPretty(summaries, sectionHeader) {
   if (summaries.length === 0) {
     return "No epics found.";
@@ -3478,6 +3913,28 @@ function summaryCommand(program2) {
         }
         return;
       }
+      const inProgressIssues = getIssues({ status: "in_progress" });
+      inProgressIssues.sort(
+        (a, b) => new Date(b.updatedAt).getTime() - new Date(a.updatedAt).getTime()
+      );
+      const inProgressSummaries = inProgressIssues.map((issue) => {
+        const summary = {
+          id: issue.id,
+          title: issue.title,
+          type: issue.type,
+          createdAt: issue.createdAt,
+          updatedAt: issue.updatedAt,
+          lastSource: issue.lastSource,
+          comments: getIssueComments(issue.id)
+        };
+        if (issue.parent) {
+          const parentIssue = getIssue(issue.parent, true);
+          if (parentIssue) {
+            summary.parent = { id: parentIssue.id, title: parentIssue.title };
+          }
+        }
+        return summary;
+      });
       const openEpics = allEpics.filter((e) => e.status !== "closed");
       const seventyTwoHoursAgo = Date.now() - 72 * 60 * 60 * 1e3;
       const closedEpics = allEpics.filter(
@@ -3495,7 +3952,12 @@ function summaryCommand(program2) {
       const closedSummaries = limitedClosed.map(buildSummary);
       if (pretty) {
         const output = [];
+        const inProgressOutput = formatInProgressPretty(inProgressSummaries);
+        if (inProgressOutput) {
+          output.push(inProgressOutput);
+        }
         if (openSummaries.length > 0) {
+          if (output.length > 0) output.push("");
           output.push(formatSummaryPretty(openSummaries, "Open Epics"));
         }
         if (closedSummaries.length > 0) {
@@ -3503,11 +3965,11 @@ function summaryCommand(program2) {
           output.push(formatSummaryPretty(closedSummaries, "Recently Closed Epics (last 72h)"));
         }
         if (output.length === 0) {
-          output.push("No epics found.");
+          output.push("No issues in progress and no epics found.");
         }
         console.log(output.join("\n"));
       } else {
-        console.log(formatJson({ open: openSummaries, closed: closedSummaries }));
+        console.log(formatJson({ inProgress: inProgressSummaries, open: openSummaries, closed: closedSummaries }));
       }
     } catch (error) {
       outputError(error, pretty);
@@ -3786,6 +4248,8 @@ createCommand(program);
 updateCommand(program);
 closeCommand(program);
 reopenCommand(program);
+deleteCommand(program);
+restoreCommand(program);
 claimCommand(program);
 listCommand(program);
 showCommand(program);