@markmdev/pebble 0.1.0 → 0.1.2

package/dist/cli/index.js

@@ -7,6 +7,7 @@ import { Command } from "commander";
 var ISSUE_TYPES = ["task", "bug", "epic"];
 var PRIORITIES = [0, 1, 2, 3, 4];
 var STATUSES = ["open", "in_progress", "blocked", "closed"];
+var EVENT_TYPES = ["create", "update", "close", "reopen", "comment"];
 var PRIORITY_LABELS = {
   0: "critical",
   1: "high",
@@ -886,6 +887,7 @@ function listCommand(program2) {
   program2.command("list").description("List issues").option("--status <status>", "Filter by status").option("-t, --type <type>", "Filter by type").option("--priority <priority>", "Filter by priority").option("--parent <id>", "Filter by parent epic").action(async (options) => {
     const pretty = program2.opts().pretty ?? false;
     try {
+      getOrCreatePebbleDir();
       const filters = {};
       if (options.status !== void 0) {
         const status = options.status;
@@ -924,6 +926,7 @@ function showCommand(program2) {
   program2.command("show <id>").description("Show issue details").action(async (id) => {
     const pretty = program2.opts().pretty ?? false;
     try {
+      getOrCreatePebbleDir();
       const resolvedId = resolveId(id);
       const issue = getIssue(resolvedId);
       if (!issue) {
@@ -941,6 +944,7 @@ function readyCommand(program2) {
   program2.command("ready").description("Show issues ready for work (no open blockers)").action(async () => {
     const pretty = program2.opts().pretty ?? false;
     try {
+      getOrCreatePebbleDir();
       const issues = getReady();
       outputIssueList(issues, pretty);
     } catch (error) {
@@ -954,6 +958,7 @@ function blockedCommand(program2) {
   program2.command("blocked").description("Show blocked issues (have open blockers)").action(async () => {
     const pretty = program2.opts().pretty ?? false;
     try {
+      getOrCreatePebbleDir();
       const issues = getBlocked();
       outputIssueList(issues, pretty);
     } catch (error) {
@@ -1157,6 +1162,7 @@ function graphCommand(program2) {
   program2.command("graph").description("Show dependency graph").option("--root <id>", "Filter to subtree rooted at issue").action(async (options) => {
     const pretty = program2.opts().pretty ?? false;
     try {
+      getOrCreatePebbleDir();
       let issues;
       if (options.root) {
         const rootId = resolveId(options.root);
@@ -1342,6 +1348,27 @@ function mergeIssuesFromFiles(filePaths) {
     _sources: Array.from(sources)
   }));
 }
+function findIssueInSources(issueId, filePaths) {
+  const allIssues = mergeIssuesFromFiles(filePaths);
+  let found = allIssues.find((i) => i.id === issueId);
+  if (!found) {
+    const matches = allIssues.filter((i) => i.id.startsWith(issueId));
+    if (matches.length === 1) {
+      found = matches[0];
+    } else if (matches.length > 1) {
+      return null;
+    }
+  }
+  if (!found) {
+    return null;
+  }
+  const targetFile = found._sources[0];
+  return { issue: found, targetFile };
+}
+function appendEventToFile(event, filePath) {
+  const line = JSON.stringify(event) + "\n";
+  fs2.appendFileSync(filePath, line, "utf-8");
+}
 function uiCommand(program2) {
   const defaultPort = process.env.PEBBLE_UI_PORT || "3333";
   program2.command("ui").description("Serve the React UI").option("--port <port>", "Port to serve on", defaultPort).option("--no-open", "Do not open browser automatically").option("--files <paths>", "Comma-separated paths to issues.jsonl files for multi-worktree view").action(async (options) => {
@@ -1422,26 +1449,16 @@ function uiCommand(program2) {
       });
       app.get("/api/issues", (_req, res) => {
         try {
-          if (isMultiWorktree()) {
-            const issues = mergeIssuesFromFiles(issueFiles);
-            res.json(issues);
-          } else {
-            const issues = getIssues({});
-            res.json(issues);
-          }
+          const issues = mergeIssuesFromFiles(issueFiles);
+          res.json(issues);
         } catch (error) {
           res.status(500).json({ error: error.message });
         }
       });
       app.get("/api/events", (_req, res) => {
         try {
-          if (isMultiWorktree()) {
-            const events = readEventsFromFiles(issueFiles);
-            res.json(events);
-          } else {
-            const events = readEvents();
-            res.json(events);
-          }
+          const events = readEventsFromFiles(issueFiles);
+          res.json(events);
         } catch (error) {
           res.status(500).json({ error: error.message });
         }
@@ -1653,12 +1670,28 @@ data: ${message}
       });
       app.put("/api/issues/:id", (req, res) => {
         try {
-          const pebbleDir = getOrCreatePebbleDir();
-          const issueId = resolveId(req.params.id);
-          const issue = getIssue(issueId);
-          if (!issue) {
-            res.status(404).json({ error: `Issue not found: ${req.params.id}` });
-            return;
+          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 = path2.join(pebbleDir, "issues.jsonl");
           }
           const { title, type, priority, status, description, parent } = req.body;
           const updates = {};
@@ -1695,14 +1728,26 @@ data: ${message}
           }
           if (parent !== void 0) {
             if (parent !== null) {
-              const parentIssue = getIssue(parent);
-              if (!parentIssue) {
-                res.status(400).json({ error: `Parent issue not found: ${parent}` });
-                return;
-              }
-              if (parentIssue.type !== "epic") {
-                res.status(400).json({ error: "Parent must be an epic" });
-                return;
+              if (isMultiWorktree()) {
+                const parentFound = findIssueInSources(parent, issueFiles);
+                if (!parentFound) {
+                  res.status(400).json({ error: `Parent issue not found: ${parent}` });
+                  return;
+                }
+                if (parentFound.issue.type !== "epic") {
+                  res.status(400).json({ error: "Parent must be an epic" });
+                  return;
+                }
+              } else {
+                const parentIssue = getIssue(parent);
+                if (!parentIssue) {
+                  res.status(400).json({ error: `Parent issue not found: ${parent}` });
+                  return;
+                }
+                if (parentIssue.type !== "epic") {
+                  res.status(400).json({ error: "Parent must be an epic" });
+                  return;
+                }
               }
             }
             updates.parent = parent;
@@ -1718,27 +1763,47 @@ data: ${message}
             timestamp,
             data: updates
           };
-          appendEvent(event, pebbleDir);
-          const updatedIssue = getIssue(issueId);
-          res.json(updatedIssue);
+          appendEventToFile(event, targetFile);
+          if (isMultiWorktree()) {
+            const updated = findIssueInSources(issueId, issueFiles);
+            res.json(updated?.issue || { ...issue, ...updates, updatedAt: timestamp });
+          } else {
+            res.json(getIssue(issueId));
+          }
         } catch (error) {
           res.status(500).json({ error: error.message });
         }
       });
       app.post("/api/issues/:id/close", (req, res) => {
         try {
-          const pebbleDir = getOrCreatePebbleDir();
-          const issueId = resolveId(req.params.id);
-          const issue = getIssue(issueId);
-          if (!issue) {
-            res.status(404).json({ error: `Issue not found: ${req.params.id}` });
-            return;
+          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 = path2.join(pebbleDir, "issues.jsonl");
           }
           if (issue.status === "closed") {
             res.status(400).json({ error: "Issue is already closed" });
             return;
           }
-          if (issue.type === "epic" && hasOpenChildren(issueId)) {
+          if (!isMultiWorktree() && issue.type === "epic" && hasOpenChildren(issueId)) {
             res.status(400).json({ error: "Cannot close epic with open children" });
             return;
           }
@@ -1750,21 +1815,41 @@ data: ${message}
             timestamp,
             data: { reason }
           };
-          appendEvent(event, pebbleDir);
-          const closedIssue = getIssue(issueId);
-          res.json(closedIssue);
+          appendEventToFile(event, targetFile);
+          if (isMultiWorktree()) {
+            const updated = findIssueInSources(issueId, issueFiles);
+            res.json(updated?.issue || { ...issue, status: "closed", updatedAt: timestamp });
+          } else {
+            res.json(getIssue(issueId));
+          }
         } catch (error) {
           res.status(500).json({ error: error.message });
         }
       });
       app.post("/api/issues/:id/reopen", (req, res) => {
         try {
-          const pebbleDir = getOrCreatePebbleDir();
-          const issueId = resolveId(req.params.id);
-          const issue = getIssue(issueId);
-          if (!issue) {
-            res.status(404).json({ error: `Issue not found: ${req.params.id}` });
-            return;
+          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 = path2.join(pebbleDir, "issues.jsonl");
           }
           if (issue.status !== "closed") {
             res.status(400).json({ error: "Issue is not closed" });
@@ -1778,21 +1863,41 @@ data: ${message}
             timestamp,
             data: { reason }
           };
-          appendEvent(event, pebbleDir);
-          const reopenedIssue = getIssue(issueId);
-          res.json(reopenedIssue);
+          appendEventToFile(event, targetFile);
+          if (isMultiWorktree()) {
+            const updated = findIssueInSources(issueId, issueFiles);
+            res.json(updated?.issue || { ...issue, status: "open", 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 {
-          const pebbleDir = getOrCreatePebbleDir();
-          const issueId = resolveId(req.params.id);
-          const issue = getIssue(issueId);
-          if (!issue) {
-            res.status(404).json({ error: `Issue not found: ${req.params.id}` });
-            return;
+          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 = path2.join(pebbleDir, "issues.jsonl");
           }
           const { text, author } = req.body;
           if (!text || typeof text !== "string" || text.trim() === "") {
@@ -1810,38 +1915,68 @@ data: ${message}
               author
             }
           };
-          appendEvent(event, pebbleDir);
-          const updatedIssue = getIssue(issueId);
-          res.json(updatedIssue);
+          appendEventToFile(event, targetFile);
+          if (isMultiWorktree()) {
+            const updated = findIssueInSources(issueId, issueFiles);
+            res.json(updated?.issue || issue);
+          } else {
+            res.json(getIssue(issueId));
+          }
         } catch (error) {
           res.status(500).json({ error: error.message });
         }
       });
       app.post("/api/issues/:id/deps", (req, res) => {
         try {
-          const pebbleDir = getOrCreatePebbleDir();
-          const issueId = resolveId(req.params.id);
-          const issue = getIssue(issueId);
-          if (!issue) {
-            res.status(404).json({ error: `Issue not found: ${req.params.id}` });
-            return;
+          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 = path2.join(pebbleDir, "issues.jsonl");
           }
           const { blockerId } = req.body;
           if (!blockerId) {
             res.status(400).json({ error: "blockerId is required" });
             return;
           }
-          const resolvedBlockerId = resolveId(blockerId);
-          const blockerIssue = getIssue(resolvedBlockerId);
-          if (!blockerIssue) {
-            res.status(404).json({ error: `Blocker issue not found: ${blockerId}` });
-            return;
+          let resolvedBlockerId;
+          if (isMultiWorktree()) {
+            const blockerFound = findIssueInSources(blockerId, issueFiles);
+            if (!blockerFound) {
+              res.status(404).json({ error: `Blocker issue not found: ${blockerId}` });
+              return;
+            }
+            resolvedBlockerId = blockerFound.issue.id;
+          } else {
+            resolvedBlockerId = resolveId(blockerId);
+            const blockerIssue = getIssue(resolvedBlockerId);
+            if (!blockerIssue) {
+              res.status(404).json({ error: `Blocker issue not found: ${blockerId}` });
+              return;
+            }
           }
           if (issue.blockedBy.includes(resolvedBlockerId)) {
             res.status(400).json({ error: "Dependency already exists" });
             return;
           }
-          if (detectCycle(issueId, resolvedBlockerId)) {
+          if (!isMultiWorktree() && detectCycle(issueId, resolvedBlockerId)) {
             res.status(400).json({ error: "Adding this dependency would create a cycle" });
             return;
           }
@@ -1854,39 +1989,74 @@ data: ${message}
               blockedBy: [...issue.blockedBy, resolvedBlockerId]
             }
           };
-          appendEvent(event, pebbleDir);
-          const updatedIssue = getIssue(issueId);
-          res.json(updatedIssue);
+          appendEventToFile(event, targetFile);
+          if (isMultiWorktree()) {
+            const updated = findIssueInSources(issueId, issueFiles);
+            res.json(updated?.issue || { ...issue, blockedBy: [...issue.blockedBy, resolvedBlockerId], updatedAt: timestamp });
+          } else {
+            res.json(getIssue(issueId));
+          }
         } catch (error) {
           res.status(500).json({ error: error.message });
         }
       });
       app.delete("/api/issues/:id/deps/:blockerId", (req, res) => {
         try {
-          const pebbleDir = getOrCreatePebbleDir();
-          const issueId = resolveId(req.params.id);
-          const issue = getIssue(issueId);
-          if (!issue) {
-            res.status(404).json({ error: `Issue not found: ${req.params.id}` });
-            return;
+          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 = path2.join(pebbleDir, "issues.jsonl");
+          }
+          let resolvedBlockerId;
+          if (isMultiWorktree()) {
+            const blockerFound = findIssueInSources(req.params.blockerId, issueFiles);
+            if (blockerFound) {
+              resolvedBlockerId = blockerFound.issue.id;
+            } else {
+              resolvedBlockerId = req.params.blockerId;
+            }
+          } else {
+            resolvedBlockerId = resolveId(req.params.blockerId);
           }
-          const resolvedBlockerId = resolveId(req.params.blockerId);
           if (!issue.blockedBy.includes(resolvedBlockerId)) {
             res.status(400).json({ error: "Dependency does not exist" });
             return;
           }
           const timestamp = (/* @__PURE__ */ new Date()).toISOString();
+          const newBlockedBy = issue.blockedBy.filter((id) => id !== resolvedBlockerId);
           const event = {
             type: "update",
             issueId,
             timestamp,
             data: {
-              blockedBy: issue.blockedBy.filter((id) => id !== resolvedBlockerId)
+              blockedBy: newBlockedBy
             }
           };
-          appendEvent(event, pebbleDir);
-          const updatedIssue = getIssue(issueId);
-          res.json(updatedIssue);
+          appendEventToFile(event, targetFile);
+          if (isMultiWorktree()) {
+            const updated = findIssueInSources(issueId, issueFiles);
+            res.json(updated?.issue || { ...issue, blockedBy: newBlockedBy, updatedAt: timestamp });
+          } else {
+            res.json(getIssue(issueId));
+          }
         } catch (error) {
           res.status(500).json({ error: error.message });
         }
@@ -2146,7 +2316,7 @@ function mergeIssues(filePaths) {
   }));
 }
 function mergeCommand(program2) {
-  program2.command("merge <files...>").description("Merge multiple issues.jsonl files into one").option("-o, --output <file>", "Output file (default: stdout)").option("--events", "Output raw events instead of computed state").option("--show-sources", "Include _sources field showing which files contained each issue").action((files, options) => {
+  program2.command("merge <files...>").description("Merge multiple issues.jsonl files into one").option("-o, --output <file>", "Output file (default: stdout)").option("--state", "Output computed state instead of raw events").option("--show-sources", "Include _sources field (only with --state)").action((files, options) => {
     const pretty = program2.opts().pretty ?? false;
     const filePaths = [];
     for (const file of files) {
@@ -2163,13 +2333,13 @@ function mergeCommand(program2) {
     }
     try {
       let output;
-      if (options.events) {
-        const events = mergeEvents(filePaths);
-        output = events.map((e) => JSON.stringify(e)).join("\n") + "\n";
-      } else {
+      if (options.state) {
         const issues = mergeIssues(filePaths);
         const outputIssues = options.showSources ? issues : issues.map(({ _sources, ...issue }) => issue);
         output = pretty ? JSON.stringify(outputIssues, null, 2) : JSON.stringify(outputIssues);
+      } else {
+        const events = mergeEvents(filePaths);
+        output = events.map((e) => JSON.stringify(e)).join("\n");
       }
       if (options.output) {
         fs4.writeFileSync(options.output, output + "\n", "utf-8");
@@ -2184,6 +2354,246 @@ function mergeCommand(program2) {
   });
 }
 
+// src/cli/commands/summary.ts
+function countChildren(epicId) {
+  const children = getChildren(epicId);
+  return {
+    total: children.length,
+    done: children.filter((c) => c.status === "closed").length,
+    in_progress: children.filter((c) => c.status === "in_progress").length,
+    open: children.filter((c) => c.status === "open").length,
+    blocked: children.filter((c) => c.status === "blocked").length
+  };
+}
+function formatSummaryPretty(summaries) {
+  if (summaries.length === 0) {
+    return "No epics found.";
+  }
+  const lines = [];
+  for (const summary of summaries) {
+    const { children } = summary;
+    const progress = children.total > 0 ? `(${children.done}/${children.total} done)` : "(no children)";
+    lines.push(`${summary.id} ${summary.title} ${progress}`);
+    if (summary.description) {
+      const desc = summary.description.split("\n")[0];
+      const truncated = desc.length > 60 ? desc.slice(0, 57) + "..." : desc;
+      lines.push(`    ${truncated}`);
+    }
+  }
+  return lines.join("\n");
+}
+function summaryCommand(program2) {
+  program2.command("summary").description("Show epic summary with child completion status").option("--status <status>", "Filter epics by status (default: open)").option("--limit <n>", "Max epics to return", "10").option("--include-closed", "Include closed epics").action(async (options) => {
+    const pretty = program2.opts().pretty ?? false;
+    try {
+      getOrCreatePebbleDir();
+      let epics = getIssues({ type: "epic" });
+      if (options.includeClosed) {
+      } else if (options.status !== void 0) {
+        const status = options.status;
+        if (!STATUSES.includes(status)) {
+          throw new Error(`Invalid status: ${status}. Must be one of: ${STATUSES.join(", ")}`);
+        }
+        epics = epics.filter((e) => e.status === status);
+      } else {
+        epics = epics.filter((e) => e.status !== "closed");
+      }
+      epics.sort(
+        (a, b) => new Date(b.updatedAt).getTime() - new Date(a.updatedAt).getTime()
+      );
+      const limit = parseInt(options.limit, 10);
+      if (limit > 0) {
+        epics = epics.slice(0, limit);
+      }
+      const summaries = epics.map((epic) => ({
+        id: epic.id,
+        title: epic.title,
+        description: epic.description,
+        status: epic.status,
+        children: countChildren(epic.id)
+      }));
+      if (pretty) {
+        console.log(formatSummaryPretty(summaries));
+      } else {
+        console.log(formatJson(summaries));
+      }
+    } catch (error) {
+      outputError(error, pretty);
+    }
+  });
+}
+
+// src/cli/commands/history.ts
+function parseDuration(duration) {
+  const match = duration.match(/^(\d+)([dhms])$/);
+  if (!match) {
+    throw new Error(`Invalid duration: ${duration}. Use format like "7d", "24h", "30m", "60s"`);
+  }
+  const value = parseInt(match[1], 10);
+  const unit = match[2];
+  const multipliers = {
+    s: 1e3,
+    m: 60 * 1e3,
+    h: 60 * 60 * 1e3,
+    d: 24 * 60 * 60 * 1e3
+  };
+  return value * multipliers[unit];
+}
+function formatRelativeTime(timestamp) {
+  const now = Date.now();
+  const then = new Date(timestamp).getTime();
+  const diff = now - then;
+  const seconds = Math.floor(diff / 1e3);
+  const minutes = Math.floor(seconds / 60);
+  const hours = Math.floor(minutes / 60);
+  const days = Math.floor(hours / 24);
+  if (days > 0) return `${days}d ago`;
+  if (hours > 0) return `${hours}h ago`;
+  if (minutes > 0) return `${minutes}m ago`;
+  return `${seconds}s ago`;
+}
+function formatHistoryPretty(entries) {
+  if (entries.length === 0) {
+    return "No events found.";
+  }
+  const lines = [];
+  for (const entry of entries) {
+    const time = formatRelativeTime(entry.timestamp);
+    const eventLabel = entry.event.charAt(0).toUpperCase() + entry.event.slice(1);
+    let line = `[${time}] ${eventLabel} ${entry.issue.id} "${entry.issue.title}" (${entry.issue.type})`;
+    if (entry.parent) {
+      line += ` under ${entry.parent.id}`;
+    }
+    lines.push(line);
+  }
+  return lines.join("\n");
+}
+function historyCommand(program2) {
+  program2.command("history").description("Show recent activity log").option("--limit <n>", "Max events to return", "20").option("--type <type>", "Filter by event type (create/close/reopen/update/comment)").option("--since <duration>", 'Only show events since (e.g., "7d", "24h")').action(async (options) => {
+    const pretty = program2.opts().pretty ?? false;
+    try {
+      getOrCreatePebbleDir();
+      const events = readEvents();
+      const state = computeState(events);
+      let filteredEvents = events;
+      if (options.type !== void 0) {
+        const eventType = options.type;
+        if (!EVENT_TYPES.includes(eventType)) {
+          throw new Error(`Invalid event type: ${eventType}. Must be one of: ${EVENT_TYPES.join(", ")}`);
+        }
+        filteredEvents = filteredEvents.filter((e) => e.type === eventType);
+      }
+      if (options.since !== void 0) {
+        const sinceMs = parseDuration(options.since);
+        const cutoff = Date.now() - sinceMs;
+        filteredEvents = filteredEvents.filter(
+          (e) => new Date(e.timestamp).getTime() >= cutoff
+        );
+      }
+      filteredEvents.sort(
+        (a, b) => new Date(b.timestamp).getTime() - new Date(a.timestamp).getTime()
+      );
+      const limit = parseInt(options.limit, 10);
+      if (limit > 0) {
+        filteredEvents = filteredEvents.slice(0, limit);
+      }
+      const entries = filteredEvents.map((event) => {
+        const issue = state.get(event.issueId);
+        const entry = {
+          timestamp: event.timestamp,
+          event: event.type,
+          issue: {
+            id: event.issueId,
+            title: issue?.title ?? "(unknown)",
+            type: issue?.type ?? "task"
+          }
+        };
+        if (issue?.parent) {
+          const parent = state.get(issue.parent);
+          if (parent) {
+            entry.parent = {
+              id: parent.id,
+              title: parent.title
+            };
+          }
+        }
+        if (event.type === "close" && event.data.reason) {
+          entry.details = { reason: event.data.reason };
+        } else if (event.type === "comment") {
+          entry.details = { text: event.data.text };
+        }
+        return entry;
+      });
+      if (pretty) {
+        console.log(formatHistoryPretty(entries));
+      } else {
+        console.log(formatJson(entries));
+      }
+    } catch (error) {
+      outputError(error, pretty);
+    }
+  });
+}
+
+// src/cli/commands/search.ts
+function searchIssues(issues, query) {
+  const lowerQuery = query.toLowerCase();
+  return issues.filter((issue) => {
+    if (issue.id.toLowerCase().includes(lowerQuery)) {
+      return true;
+    }
+    if (issue.title.toLowerCase().includes(lowerQuery)) {
+      return true;
+    }
+    if (issue.description?.toLowerCase().includes(lowerQuery)) {
+      return true;
+    }
+    if (issue.comments.some((c) => c.text.toLowerCase().includes(lowerQuery))) {
+      return true;
+    }
+    return false;
+  });
+}
+function searchCommand(program2) {
+  program2.command("search <query>").description("Search issues by text in title, description, and comments").option("--status <status>", "Filter by status").option("-t, --type <type>", "Filter by type").option("--limit <n>", "Max results", "20").action(async (query, options) => {
+    const pretty = program2.opts().pretty ?? false;
+    try {
+      getOrCreatePebbleDir();
+      let issues = getIssues();
+      if (options.status !== void 0) {
+        const status = options.status;
+        if (!STATUSES.includes(status)) {
+          throw new Error(`Invalid status: ${status}. Must be one of: ${STATUSES.join(", ")}`);
+        }
+        issues = issues.filter((i) => i.status === status);
+      }
+      if (options.type !== void 0) {
+        const type = options.type;
+        if (!ISSUE_TYPES.includes(type)) {
+          throw new Error(`Invalid type: ${type}. Must be one of: ${ISSUE_TYPES.join(", ")}`);
+        }
+        issues = issues.filter((i) => i.type === type);
+      }
+      let results = searchIssues(issues, query);
+      const lowerQuery = query.toLowerCase();
+      results.sort((a, b) => {
+        const aInTitle = a.title.toLowerCase().includes(lowerQuery);
+        const bInTitle = b.title.toLowerCase().includes(lowerQuery);
+        if (aInTitle && !bInTitle) return -1;
+        if (!aInTitle && bInTitle) return 1;
+        return new Date(b.updatedAt).getTime() - new Date(a.updatedAt).getTime();
+      });
+      const limit = parseInt(options.limit, 10);
+      if (limit > 0) {
+        results = results.slice(0, limit);
+      }
+      outputIssueList(results, pretty);
+    } catch (error) {
+      outputError(error, pretty);
+    }
+  });
+}
+
 // src/cli/index.ts
 var program = new Command();
 program.name("pebble").description("A lightweight JSONL-based issue tracker").version("0.1.0");
@@ -2203,5 +2613,8 @@ graphCommand(program);
 uiCommand(program);
 importCommand(program);
 mergeCommand(program);
+summaryCommand(program);
+historyCommand(program);
+searchCommand(program);
 program.parse();
 //# sourceMappingURL=index.js.map