@markmdev/pebble 0.1.1 → 0.1.2

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

@@ -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",
@@ -2315,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) {
@@ -2332,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");
@@ -2353,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");
@@ -2372,5 +2613,8 @@ graphCommand(program);
 uiCommand(program);
 importCommand(program);
 mergeCommand(program);
+summaryCommand(program);
+historyCommand(program);
+searchCommand(program);
 program.parse();
 //# sourceMappingURL=index.js.map