@markmdev/pebble 0.1.1 → 0.1.3

package/README.md

@@ -13,23 +13,25 @@ A lightweight, JSONL-based issue tracker with CLI and React UI.
 ## Installation
 
 ```bash
-npm install -g pebble
+npm install -g @markmdev/pebble
 ```
 
+After installation, the `pb` command is available globally.
+
 ## Quick Start
 
 ```bash
 # Create your first issue (auto-initializes .pebble/ directory)
-pebble create "Fix login bug" -t bug -p 1
+pb create "Fix login bug" -t bug -p 1
 
 # List all issues
-pebble list
+pb list
 
 # Show ready issues (no open blockers)
-pebble ready
+pb ready
 
 # View in the browser
-pebble ui
+pb ui
 ```
 
 ## Commands
@@ -38,37 +40,37 @@ pebble ui
 
 | Command | Description |
 |---------|-------------|
-| `pebble ready` | Issues with no open blockers |
-| `pebble blocked` | Issues with open blockers |
-| `pebble list [options]` | List issues with filters |
-| `pebble show <id>` | Full issue details |
+| `pb ready` | Issues with no open blockers |
+| `pb blocked` | Issues with open blockers |
+| `pb list [options]` | List issues with filters |
+| `pb show <id>` | Full issue details |
 
 ### Mutations
 
 | Command | Description |
 |---------|-------------|
-| `pebble create <title> [options]` | Create an issue |
-| `pebble update <ids...> [options]` | Update issues (supports batch) |
-| `pebble claim <ids...>` | Set status to in_progress (shorthand) |
-| `pebble close <ids...> [--reason] [--comment]` | Close issues (supports batch) |
-| `pebble reopen <id> [--reason]` | Reopen an issue |
+| `pb create <title> [options]` | Create an issue |
+| `pb update <ids...> [options]` | Update issues (supports batch) |
+| `pb claim <ids...>` | Set status to in_progress (shorthand) |
+| `pb close <ids...> [--reason] [--comment]` | Close issues (supports batch) |
+| `pb reopen <id> [--reason]` | Reopen an issue |
 
 ### Dependencies
 
 | Command | Description |
 |---------|-------------|
-| `pebble dep add <id> <blocker>` | Add blocking dependency |
-| `pebble dep remove <id> <blocker>` | Remove dependency |
-| `pebble dep list <id>` | Show dependencies |
-| `pebble dep tree <id>` | Show dependency tree |
+| `pb dep add <id> <blocker>` | Add blocking dependency |
+| `pb dep remove <id> <blocker>` | Remove dependency |
+| `pb dep list <id>` | Show dependencies |
+| `pb dep tree <id>` | Show dependency tree |
 
 ### Comments & Visualization
 
 | Command | Description |
 |---------|-------------|
-| `pebble comments add <id> <text>` | Add a comment |
-| `pebble graph [--root id]` | Show dependency graph |
-| `pebble ui [--port 3333]` | Serve React UI |
+| `pb comments add <id> <text>` | Add a comment |
+| `pb graph [--root id]` | Show dependency graph |
+| `pb ui [--port 3333]` | Serve React UI |
 
 ## Options
 
@@ -129,7 +131,7 @@ All data is stored in `.pebble/issues.jsonl` as append-only events:
 
 ## UI Features
 
-The React UI (`pebble ui`) provides full CRUD capabilities with real-time updates:
+The React UI (`pb ui`) provides full CRUD capabilities with real-time updates:
 
 - **Issue List**: Hierarchical view (epics with children), sorting, filtering, search
 - **Create Issues**: "New Issue" button opens creation dialog

package/dist/cli/index.js

@@ -4,9 +4,10 @@
 import { Command } from "commander";
 
 // src/shared/types.ts
-var ISSUE_TYPES = ["task", "bug", "epic"];
+var ISSUE_TYPES = ["task", "bug", "epic", "verification"];
 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",
@@ -23,7 +24,8 @@ var STATUS_LABELS = {
 var TYPE_LABELS = {
   task: "Task",
   bug: "Bug",
-  epic: "Epic"
+  epic: "Epic",
+  verification: "Verification"
 };
 
 // src/cli/lib/storage.ts
@@ -175,6 +177,7 @@ function computeState(events) {
           description: createEvent.data.description,
           parent: createEvent.data.parent,
           blockedBy: [],
+          verifies: createEvent.data.verifies,
           comments: [],
           createdAt: event.timestamp,
           updatedAt: event.timestamp
@@ -315,6 +318,12 @@ function getReady() {
         return false;
       }
     }
+    if (issue.type === "verification" && issue.verifies) {
+      const target = state.get(issue.verifies);
+      if (!target || target.status !== "closed") {
+        return false;
+      }
+    }
     return true;
   });
 }
@@ -401,10 +410,46 @@ function getChildren(epicId) {
   const state = computeState(events);
   return Array.from(state.values()).filter((issue) => issue.parent === epicId);
 }
+function getVerifications(issueId) {
+  const events = readEvents();
+  const state = computeState(events);
+  return Array.from(state.values()).filter((issue) => issue.verifies === issueId);
+}
 function hasOpenChildren(epicId) {
   const children = getChildren(epicId);
   return children.some((child) => child.status !== "closed");
 }
+function getNewlyUnblocked(closedIssueId) {
+  const events = readEvents();
+  const state = computeState(events);
+  const result = [];
+  for (const issue of state.values()) {
+    if (issue.status === "closed") continue;
+    let isUnblockedByThis = false;
+    if (issue.blockedBy.includes(closedIssueId)) {
+      const allBlockersClosed = issue.blockedBy.every((blockerId) => {
+        const blocker = state.get(blockerId);
+        return blocker?.status === "closed";
+      });
+      if (allBlockersClosed) {
+        isUnblockedByThis = true;
+      }
+    }
+    if (issue.type === "verification" && issue.verifies === closedIssueId) {
+      const allBlockersClosed = issue.blockedBy.every((blockerId) => {
+        const blocker = state.get(blockerId);
+        return blocker?.status === "closed";
+      });
+      if (allBlockersClosed) {
+        isUnblockedByThis = true;
+      }
+    }
+    if (isUnblockedByThis) {
+      result.push(issue);
+    }
+  }
+  return result;
+}
 
 // src/cli/lib/output.ts
 function formatJson(data) {
@@ -426,7 +471,7 @@ function truncate(str, maxLength) {
 function pad(str, width) {
   return str.padEnd(width);
 }
-function formatIssuePretty(issue) {
+function formatIssuePrettyWithBlocking(issue, blocking) {
   const lines = [];
   lines.push(`${issue.id} - ${issue.title}`);
   lines.push("\u2500".repeat(60));
@@ -445,6 +490,10 @@ function formatIssuePretty(issue) {
     lines.push("");
     lines.push(`Blocked by: ${issue.blockedBy.join(", ")}`);
   }
+  if (blocking.length > 0) {
+    lines.push("");
+    lines.push(`Blocking: ${blocking.map((i) => i.id).join(", ")}`);
+  }
   if (issue.comments.length > 0) {
     lines.push("");
     lines.push("Comments:");
@@ -525,11 +574,15 @@ function formatErrorPretty(error) {
   const message = error instanceof Error ? error.message : error;
   return `Error: ${message}`;
 }
-function outputIssue(issue, pretty) {
+function outputIssueWithBlocking(issue, blocking, pretty) {
   if (pretty) {
-    console.log(formatIssuePretty(issue));
+    console.log(formatIssuePrettyWithBlocking(issue, blocking));
   } else {
-    console.log(formatJson(issue));
+    const output = {
+      ...issue,
+      blocking: blocking.map((i) => i.id)
+    };
+    console.log(formatJson(output));
   }
 }
 function outputMutationSuccess(id, pretty) {
@@ -557,13 +610,19 @@ function outputError(error, pretty) {
 
 // src/cli/commands/create.ts
 function createCommand(program2) {
-  program2.command("create <title>").description("Create a new issue").option("-t, --type <type>", "Issue type (task, bug, epic)", "task").option("-p, --priority <priority>", "Priority (0-4)", "2").option("-d, --description <desc>", "Description").option("--parent <id>", "Parent epic ID").action(async (title, options) => {
+  program2.command("create <title>").description("Create a new issue").option("-t, --type <type>", "Issue type (task, bug, epic, verification)", "task").option("-p, --priority <priority>", "Priority (0-4)", "2").option("-d, --description <desc>", "Description").option("--parent <id>", "Parent epic ID").option("--verifies <id>", "ID of issue this verifies (sets type to verification)").action(async (title, options) => {
     const pretty = program2.opts().pretty ?? false;
     try {
-      const type = options.type;
+      let type = options.type;
+      if (options.verifies && type !== "verification") {
+        type = "verification";
+      }
       if (!ISSUE_TYPES.includes(type)) {
         throw new Error(`Invalid type: ${type}. Must be one of: ${ISSUE_TYPES.join(", ")}`);
       }
+      if (type === "verification" && !options.verifies) {
+        throw new Error("Verification issues require --verifies <id> to specify the issue being verified");
+      }
       const priority = parseInt(options.priority, 10);
       if (!PRIORITIES.includes(priority)) {
         throw new Error(`Invalid priority: ${options.priority}. Must be 0-4`);
@@ -584,6 +643,14 @@ function createCommand(program2) {
           throw new Error(`Cannot add children to closed epic: ${parentId}`);
         }
       }
+      let verifiesId;
+      if (options.verifies) {
+        verifiesId = resolveId(options.verifies);
+        const target = getIssue(verifiesId);
+        if (!target) {
+          throw new Error(`Target issue not found: ${options.verifies}`);
+        }
+      }
       const id = generateId(config.prefix);
       const timestamp = (/* @__PURE__ */ new Date()).toISOString();
       const event = {
@@ -595,7 +662,8 @@ function createCommand(program2) {
           type,
           priority,
           description: options.description,
-          parent: parentId
+          parent: parentId,
+          verifies: verifiesId
         }
       };
       appendEvent(event, pebbleDir);
@@ -745,7 +813,12 @@ function closeCommand(program2) {
             }
           };
           appendEvent(closeEvent, pebbleDir);
-          results.push({ id: resolvedId, success: true });
+          const unblocked = getNewlyUnblocked(resolvedId);
+          results.push({
+            id: resolvedId,
+            success: true,
+            unblocked: unblocked.length > 0 ? unblocked.map((i) => ({ id: i.id, title: i.title })) : void 0
+          });
         } catch (error) {
           results.push({ id, success: false, error: error.message });
         }
@@ -753,7 +826,22 @@ function closeCommand(program2) {
       if (allIds.length === 1) {
         const result = results[0];
         if (result.success) {
-          outputMutationSuccess(result.id, pretty);
+          if (pretty) {
+            console.log(`\u2713 ${result.id}`);
+            if (result.unblocked && result.unblocked.length > 0) {
+              console.log(`
+Unblocked:`);
+              for (const u of result.unblocked) {
+                console.log(`  \u2192 ${u.id} - ${u.title}`);
+              }
+            }
+          } else {
+            console.log(formatJson({
+              id: result.id,
+              success: true,
+              ...result.unblocked && { unblocked: result.unblocked }
+            }));
+          }
         } else {
           throw new Error(result.error || "Unknown error");
         }
@@ -762,6 +850,11 @@ function closeCommand(program2) {
           for (const result of results) {
             if (result.success) {
               console.log(`\u2713 ${result.id}`);
+              if (result.unblocked && result.unblocked.length > 0) {
+                for (const u of result.unblocked) {
+                  console.log(`  \u2192 ${u.id} - ${u.title}`);
+                }
+              }
             } else {
               console.log(`\u2717 ${result.id}: ${result.error}`);
             }
@@ -770,7 +863,8 @@ function closeCommand(program2) {
           console.log(formatJson(results.map((r) => ({
             id: r.id,
             success: r.success,
-            ...r.error && { error: r.error }
+            ...r.error && { error: r.error },
+            ...r.unblocked && { unblocked: r.unblocked }
           }))));
         }
       }
@@ -931,7 +1025,8 @@ function showCommand(program2) {
       if (!issue) {
         throw new Error(`Issue not found: ${id}`);
       }
-      outputIssue(issue, pretty);
+      const blocking = getBlocking(resolvedId);
+      outputIssueWithBlocking(issue, blocking, pretty);
     } catch (error) {
       outputError(error, pretty);
     }
@@ -2315,7 +2410,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) {
@@ -2332,13 +2427,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");
@@ -2353,10 +2448,308 @@ 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.parent) {
+      lines.push(`    Parent: ${summary.parent.id} "${summary.parent.title}"`);
+    }
+    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) => {
+        const summary = {
+          id: epic.id,
+          title: epic.title,
+          description: epic.description,
+          status: epic.status,
+          children: countChildren(epic.id)
+        };
+        if (epic.parent) {
+          const parentIssue = getIssue(epic.parent);
+          if (parentIssue) {
+            summary.parent = {
+              id: parentIssue.id,
+              title: parentIssue.title
+            };
+          }
+        }
+        return summary;
+      });
+      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 <types>", "Filter by event type(s), comma-separated (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 types = options.type.split(",").map((t) => t.trim());
+        for (const t of types) {
+          if (!EVENT_TYPES.includes(t)) {
+            throw new Error(`Invalid event type: ${t}. Must be one of: ${EVENT_TYPES.join(", ")}`);
+          }
+        }
+        filteredEvents = filteredEvents.filter((e) => types.includes(e.type));
+      }
+      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/commands/verifications.ts
+function verificationsCommand(program2) {
+  program2.command("verifications <id>").description("List verification issues for a given issue").action(async (id) => {
+    const pretty = program2.opts().pretty ?? false;
+    try {
+      getOrCreatePebbleDir();
+      const resolvedId = resolveId(id);
+      const issue = getIssue(resolvedId);
+      if (!issue) {
+        throw new Error(`Issue not found: ${id}`);
+      }
+      const verifications = getVerifications(resolvedId);
+      if (pretty) {
+        if (verifications.length === 0) {
+          console.log(`No verifications for ${resolvedId}`);
+        } else {
+          console.log(`Verifications for ${resolvedId} "${issue.title}"`);
+          console.log("\u2500".repeat(50));
+          for (const v of verifications) {
+            const status = v.status === "closed" ? "\u2713" : "\u25CB";
+            console.log(`  ${status} ${v.id} - ${v.title}`);
+          }
+          console.log("");
+          console.log(`Total: ${verifications.length} verification(s)`);
+        }
+      } else {
+        console.log(formatJson({
+          issueId: resolvedId,
+          verifications: verifications.map((v) => ({
+            id: v.id,
+            title: v.title,
+            status: v.status
+          }))
+        }));
+      }
+    } 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");
-program.option("--pretty", "Human-readable output (default: JSON)");
+program.option("-P, --pretty", "Human-readable output (default: JSON)");
 createCommand(program);
 updateCommand(program);
 closeCommand(program);
@@ -2372,5 +2765,9 @@ graphCommand(program);
 uiCommand(program);
 importCommand(program);
 mergeCommand(program);
+summaryCommand(program);
+historyCommand(program);
+searchCommand(program);
+verificationsCommand(program);
 program.parse();
 //# sourceMappingURL=index.js.map