@markmdev/pebble 0.1.4 → 0.1.6

package/dist/cli/index.js

@@ -1,4 +1,10 @@
 #!/usr/bin/env node
+var __require = /* @__PURE__ */ ((x) => typeof require !== "undefined" ? require : typeof Proxy !== "undefined" ? new Proxy(x, {
+  get: (a, b) => (typeof require !== "undefined" ? require : a)[b]
+}) : x)(function(x) {
+  if (typeof require !== "undefined") return require.apply(this, arguments);
+  throw Error('Dynamic require of "' + x + '" is not supported');
+});
 
 // src/cli/index.ts
 import { Command } from "commander";
@@ -143,7 +149,7 @@ function getConfigPath(pebbleDir) {
 function getConfig(pebbleDir) {
   const configPath = getConfigPath(pebbleDir);
   if (!fs.existsSync(configPath)) {
-    throw new Error("Config file not found. Initialize .pebble first.");
+    throw new Error("No .pebble directory found. Run 'pb init' to initialize.");
   }
   const content = fs.readFileSync(configPath, "utf-8");
   return JSON.parse(content);
@@ -205,7 +211,7 @@ function computeState(events) {
             issue.description = updateEvent.data.description;
           }
           if (updateEvent.data.parent !== void 0) {
-            issue.parent = updateEvent.data.parent;
+            issue.parent = updateEvent.data.parent || void 0;
           }
           if (updateEvent.data.blockedBy !== void 0) {
             issue.blockedBy = updateEvent.data.blockedBy;
@@ -607,10 +613,48 @@ function outputError(error, pretty) {
   }
   process.exit(1);
 }
+function formatIssueListVerbose(issues) {
+  if (issues.length === 0) {
+    return "No issues found.";
+  }
+  const lines = [];
+  for (const info of issues) {
+    const { issue, blocking, children, verifications, blockers } = info;
+    lines.push(`${issue.id} - ${issue.title}`);
+    lines.push("\u2500".repeat(60));
+    lines.push(`  Type:          ${formatType(issue.type)}`);
+    lines.push(`  Priority:      P${issue.priority}`);
+    lines.push(`  Status:        ${issue.status}`);
+    lines.push(`  Parent:        ${issue.parent || "-"}`);
+    lines.push(`  Children:      ${issue.type === "epic" ? children : "-"}`);
+    lines.push(`  Blocking:      ${blocking.length > 0 ? blocking.join(", ") : "[]"}`);
+    lines.push(`  Verifications: ${verifications}`);
+    if (blockers && blockers.length > 0) {
+      lines.push(`  Blocked by:    ${blockers.join(", ")}`);
+    }
+    lines.push("");
+  }
+  lines.push(`Total: ${issues.length} issue(s)`);
+  return lines.join("\n");
+}
+function outputIssueListVerbose(issues, pretty) {
+  if (pretty) {
+    console.log(formatIssueListVerbose(issues));
+  } else {
+    const output = issues.map(({ issue, blocking, children, verifications, blockers }) => ({
+      ...issue,
+      blocking,
+      childrenCount: issue.type === "epic" ? children : void 0,
+      verificationsCount: verifications,
+      ...blockers && { openBlockers: blockers }
+    }));
+    console.log(formatJson(output));
+  }
+}
 
 // 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, 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) => {
+  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)").option("--blocked-by <ids>", "Comma-separated IDs of issues that block this one").option("--blocks <ids>", "Comma-separated IDs of issues this one will block").action(async (title, options) => {
     const pretty = program2.opts().pretty ?? false;
     try {
       let type = options.type;
@@ -651,6 +695,33 @@ function createCommand(program2) {
           throw new Error(`Target issue not found: ${options.verifies}`);
         }
       }
+      const blockedByIds = [];
+      if (options.blockedBy) {
+        const ids = options.blockedBy.split(",").map((s) => s.trim()).filter(Boolean);
+        for (const rawId of ids) {
+          const resolvedId = resolveId(rawId);
+          const blocker = getIssue(resolvedId);
+          if (!blocker) {
+            throw new Error(`Blocker issue not found: ${rawId}`);
+          }
+          if (blocker.status === "closed") {
+            throw new Error(`Cannot be blocked by closed issue: ${resolvedId}`);
+          }
+          blockedByIds.push(resolvedId);
+        }
+      }
+      const blocksIds = [];
+      if (options.blocks) {
+        const ids = options.blocks.split(",").map((s) => s.trim()).filter(Boolean);
+        for (const rawId of ids) {
+          const resolvedId = resolveId(rawId);
+          const blocked = getIssue(resolvedId);
+          if (!blocked) {
+            throw new Error(`Issue to block not found: ${rawId}`);
+          }
+          blocksIds.push(resolvedId);
+        }
+      }
       const id = generateId(config.prefix);
       const timestamp = (/* @__PURE__ */ new Date()).toISOString();
       const event = {
@@ -667,6 +738,26 @@ function createCommand(program2) {
         }
       };
       appendEvent(event, pebbleDir);
+      if (blockedByIds.length > 0) {
+        const depEvent = {
+          type: "update",
+          issueId: id,
+          timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+          data: { blockedBy: blockedByIds }
+        };
+        appendEvent(depEvent, pebbleDir);
+      }
+      for (const targetId of blocksIds) {
+        const target = getIssue(targetId);
+        const existingBlockers = target?.blockedBy || [];
+        const depEvent = {
+          type: "update",
+          issueId: targetId,
+          timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+          data: { blockedBy: [...existingBlockers, id] }
+        };
+        appendEvent(depEvent, pebbleDir);
+      }
       outputMutationSuccess(id, pretty);
     } catch (error) {
       outputError(error, pretty);
@@ -676,7 +767,7 @@ function createCommand(program2) {
 
 // src/cli/commands/update.ts
 function updateCommand(program2) {
-  program2.command("update <ids...>").description("Update issues. Supports multiple IDs.").option("--status <status>", "Status (open, in_progress, blocked, closed)").option("--priority <priority>", "Priority (0-4)").option("--title <title>", "Title").option("--description <desc>", "Description").action(async (ids, options) => {
+  program2.command("update <ids...>").description("Update issues. Supports multiple IDs.").option("--status <status>", "Status (open, in_progress, blocked, closed)").option("--priority <priority>", "Priority (0-4)").option("--title <title>", "Title").option("--description <desc>", "Description").option("--parent <id>", 'Parent epic ID (use "null" to remove parent)').action(async (ids, options) => {
     const pretty = program2.opts().pretty ?? false;
     try {
       const pebbleDir = getOrCreatePebbleDir();
@@ -710,8 +801,27 @@ function updateCommand(program2) {
         data.description = options.description;
         hasChanges = true;
       }
+      if (options.parent !== void 0) {
+        if (options.parent.toLowerCase() === "null") {
+          data.parent = "";
+        } else {
+          const parentId = resolveId(options.parent);
+          const parentIssue = getIssue(parentId);
+          if (!parentIssue) {
+            throw new Error(`Parent issue not found: ${options.parent}`);
+          }
+          if (parentIssue.type !== "epic") {
+            throw new Error(`Parent must be an epic. ${parentId} is a ${parentIssue.type}`);
+          }
+          if (parentIssue.status === "closed") {
+            throw new Error(`Cannot set parent to closed epic: ${parentId}`);
+          }
+          data.parent = parentId;
+        }
+        hasChanges = true;
+      }
       if (!hasChanges) {
-        throw new Error("No changes specified. Use --status, --priority, --title, or --description");
+        throw new Error("No changes specified. Use --status, --priority, --title, --description, or --parent");
       }
       const results = [];
       for (const id of allIds) {
@@ -1035,12 +1145,22 @@ function showCommand(program2) {
 
 // src/cli/commands/ready.ts
 function readyCommand(program2) {
-  program2.command("ready").description("Show issues ready for work (no open blockers)").action(async () => {
+  program2.command("ready").description("Show issues ready for work (no open blockers)").option("-v, --verbose", "Show expanded details (parent, children, blocking, verifications)").action(async (options) => {
     const pretty = program2.opts().pretty ?? false;
     try {
       getOrCreatePebbleDir();
       const issues = getReady();
-      outputIssueList(issues, pretty);
+      if (options.verbose) {
+        const verboseIssues = issues.map((issue) => ({
+          issue,
+          blocking: getBlocking(issue.id).map((i) => i.id),
+          children: getChildren(issue.id).length,
+          verifications: getVerifications(issue.id).length
+        }));
+        outputIssueListVerbose(verboseIssues, pretty);
+      } else {
+        outputIssueList(issues, pretty);
+      }
     } catch (error) {
       outputError(error, pretty);
     }
@@ -1049,12 +1169,27 @@ function readyCommand(program2) {
 
 // src/cli/commands/blocked.ts
 function blockedCommand(program2) {
-  program2.command("blocked").description("Show blocked issues (have open blockers)").action(async () => {
+  program2.command("blocked").description("Show blocked issues (have open blockers)").option("-v, --verbose", "Show expanded details including WHY each issue is blocked").action(async (options) => {
     const pretty = program2.opts().pretty ?? false;
     try {
       getOrCreatePebbleDir();
       const issues = getBlocked();
-      outputIssueList(issues, pretty);
+      if (options.verbose) {
+        const verboseIssues = issues.map((issue) => {
+          const allBlockers = getBlockers(issue.id);
+          const openBlockers = allBlockers.filter((b) => b.status !== "closed").map((b) => b.id);
+          return {
+            issue,
+            blocking: getBlocking(issue.id).map((i) => i.id),
+            children: getChildren(issue.id).length,
+            verifications: getVerifications(issue.id).length,
+            blockers: openBlockers
+          };
+        });
+        outputIssueListVerbose(verboseIssues, pretty);
+      } else {
+        outputIssueList(issues, pretty);
+      }
     } catch (error) {
       outputError(error, pretty);
     }
@@ -1410,15 +1545,20 @@ async function findAvailablePort(startPort, maxAttempts = 10) {
   }
   throw new Error(`No available port found (tried ${startPort}-${startPort + maxAttempts - 1})`);
 }
-function readEventsFromFiles(filePaths) {
-  const allEvents = [];
+function mergeEventsFromFiles(filePaths) {
+  const merged = /* @__PURE__ */ new Map();
   for (const filePath of filePaths) {
     const events = readEventsFromFile(filePath);
     for (const event of events) {
-      allEvents.push({ ...event, _source: filePath });
+      const key = `${event.issueId}-${event.timestamp}-${event.type}`;
+      if (!merged.has(key)) {
+        merged.set(key, event);
+      }
     }
   }
-  return allEvents;
+  return Array.from(merged.values()).sort(
+    (a, b) => new Date(a.timestamp).getTime() - new Date(b.timestamp).getTime()
+  );
 }
 function mergeIssuesFromFiles(filePaths) {
   const merged = /* @__PURE__ */ new Map();
@@ -1541,6 +1681,57 @@ function uiCommand(program2) {
           res.status(500).json({ error: error.message });
         }
       });
+      app.get("/api/worktrees", (_req, res) => {
+        try {
+          const { execSync } = __require("child_process");
+          let worktreeOutput;
+          try {
+            worktreeOutput = execSync("git worktree list --porcelain", {
+              encoding: "utf-8",
+              cwd: process.cwd()
+            });
+          } catch {
+            res.json({ worktrees: [] });
+            return;
+          }
+          const worktrees = [];
+          const blocks = worktreeOutput.trim().split("\n\n");
+          for (const block of blocks) {
+            const lines = block.split("\n");
+            let worktreePath = "";
+            let branch = null;
+            for (const line of lines) {
+              if (line.startsWith("worktree ")) {
+                worktreePath = line.slice("worktree ".length);
+              } else if (line.startsWith("branch ")) {
+                branch = line.slice("branch ".length).replace("refs/heads/", "");
+              }
+            }
+            if (worktreePath) {
+              const issuesFile = path2.join(worktreePath, ".pebble", "issues.jsonl");
+              const hasIssues = fs2.existsSync(issuesFile);
+              const isActive = issueFiles.includes(issuesFile);
+              let issueCount = 0;
+              if (hasIssues) {
+                const events = readEventsFromFile(issuesFile);
+                const state = computeState(events);
+                issueCount = state.size;
+              }
+              worktrees.push({
+                path: worktreePath,
+                branch,
+                issuesFile: hasIssues ? issuesFile : null,
+                hasIssues,
+                isActive,
+                issueCount
+              });
+            }
+          }
+          res.json({ worktrees });
+        } catch (error) {
+          res.status(500).json({ error: error.message });
+        }
+      });
       app.get("/api/issues", (_req, res) => {
         try {
           const issues = mergeIssuesFromFiles(issueFiles);
@@ -1551,7 +1742,7 @@ function uiCommand(program2) {
       });
       app.get("/api/events", (_req, res) => {
         try {
-          const events = readEventsFromFiles(issueFiles);
+          const events = mergeEventsFromFiles(issueFiles);
           res.json(events);
         } catch (error) {
           res.status(500).json({ error: error.message });
@@ -2377,15 +2568,19 @@ function generateSuffix() {
 import * as fs4 from "fs";
 import * as path4 from "path";
 function mergeEvents(filePaths) {
-  const allEvents = [];
+  const seen = /* @__PURE__ */ new Map();
   for (const filePath of filePaths) {
     const events = readEventsFromFile(filePath);
     for (const event of events) {
-      allEvents.push({ ...event, _source: filePath });
+      const key = `${event.issueId}-${event.timestamp}-${event.type}`;
+      if (!seen.has(key)) {
+        seen.set(key, event);
+      }
     }
   }
+  const allEvents = Array.from(seen.values());
   allEvents.sort((a, b) => new Date(a.timestamp).getTime() - new Date(b.timestamp).getTime());
-  return allEvents.map(({ _source, ...event }) => event);
+  return allEvents;
 }
 function mergeIssues(filePaths) {
   const merged = /* @__PURE__ */ new Map();
@@ -2746,6 +2941,29 @@ function verificationsCommand(program2) {
   });
 }
 
+// src/cli/commands/init.ts
+import * as path5 from "path";
+function initCommand(program2) {
+  program2.command("init").description("Initialize a new .pebble directory in the current directory").option("--force", "Re-initialize even if .pebble already exists").action((options) => {
+    const existing = discoverPebbleDir();
+    if (existing && !options.force) {
+      console.error(JSON.stringify({
+        error: "Already initialized",
+        path: existing,
+        hint: "Use --force to re-initialize"
+      }));
+      process.exit(1);
+    }
+    const pebbleDir = ensurePebbleDir(process.cwd());
+    console.log(JSON.stringify({
+      initialized: true,
+      path: pebbleDir,
+      configPath: path5.join(pebbleDir, "config.json"),
+      issuesPath: path5.join(pebbleDir, "issues.jsonl")
+    }));
+  });
+}
+
 // src/cli/index.ts
 var program = new Command();
 program.name("pebble").description("A lightweight JSONL-based issue tracker").version("0.1.0");
@@ -2769,5 +2987,6 @@ summaryCommand(program);
 historyCommand(program);
 searchCommand(program);
 verificationsCommand(program);
+initCommand(program);
 program.parse();
 //# sourceMappingURL=index.js.map