@markmdev/pebble 0.1.0

package/dist/cli/index.js

@@ -0,0 +1,2207 @@
+#!/usr/bin/env node
+
+// src/cli/index.ts
+import { Command } from "commander";
+
+// src/shared/types.ts
+var ISSUE_TYPES = ["task", "bug", "epic"];
+var PRIORITIES = [0, 1, 2, 3, 4];
+var STATUSES = ["open", "in_progress", "blocked", "closed"];
+var PRIORITY_LABELS = {
+  0: "critical",
+  1: "high",
+  2: "medium",
+  3: "low",
+  4: "backlog"
+};
+var STATUS_LABELS = {
+  open: "Open",
+  in_progress: "In Progress",
+  blocked: "Blocked",
+  closed: "Closed"
+};
+var TYPE_LABELS = {
+  task: "Task",
+  bug: "Bug",
+  epic: "Epic"
+};
+
+// src/cli/lib/storage.ts
+import * as fs from "fs";
+import * as path from "path";
+
+// src/cli/lib/id.ts
+import * as crypto from "crypto";
+var ID_CHARS = "abcdefghijklmnopqrstuvwxyz0123456789";
+function randomAlphanumeric(length) {
+  const bytes = crypto.randomBytes(length);
+  let result = "";
+  for (let i = 0; i < length; i++) {
+    result += ID_CHARS[bytes[i] % ID_CHARS.length];
+  }
+  return result;
+}
+function generateId(prefix) {
+  const suffix = randomAlphanumeric(6);
+  return `${prefix}-${suffix}`;
+}
+function derivePrefix(folderName) {
+  const clean = folderName.replace(/[^a-zA-Z0-9]/g, "");
+  return clean.slice(0, 4).toUpperCase().padEnd(4, "X");
+}
+
+// src/cli/lib/storage.ts
+var PEBBLE_DIR = ".pebble";
+var ISSUES_FILE = "issues.jsonl";
+var CONFIG_FILE = "config.json";
+function discoverPebbleDir(startDir = process.cwd()) {
+  let currentDir = path.resolve(startDir);
+  const root = path.parse(currentDir).root;
+  while (currentDir !== root) {
+    const pebbleDir = path.join(currentDir, PEBBLE_DIR);
+    if (fs.existsSync(pebbleDir) && fs.statSync(pebbleDir).isDirectory()) {
+      return pebbleDir;
+    }
+    currentDir = path.dirname(currentDir);
+  }
+  const rootPebble = path.join(root, PEBBLE_DIR);
+  if (fs.existsSync(rootPebble) && fs.statSync(rootPebble).isDirectory()) {
+    return rootPebble;
+  }
+  return null;
+}
+function getPebbleDir() {
+  const dir = discoverPebbleDir();
+  if (!dir) {
+    throw new Error("No .pebble directory found. Run a create command to initialize.");
+  }
+  return dir;
+}
+function ensurePebbleDir(baseDir = process.cwd()) {
+  const pebbleDir = path.join(baseDir, PEBBLE_DIR);
+  if (!fs.existsSync(pebbleDir)) {
+    fs.mkdirSync(pebbleDir, { recursive: true });
+    const folderName = path.basename(baseDir);
+    const config = {
+      prefix: derivePrefix(folderName),
+      version: "0.1.0"
+    };
+    setConfig(config, pebbleDir);
+    const issuesPath = path.join(pebbleDir, ISSUES_FILE);
+    fs.writeFileSync(issuesPath, "", "utf-8");
+  }
+  return pebbleDir;
+}
+function getIssuesPath(pebbleDir) {
+  const dir = pebbleDir ?? getPebbleDir();
+  return path.join(dir, ISSUES_FILE);
+}
+function appendEvent(event, pebbleDir) {
+  const issuesPath = getIssuesPath(pebbleDir);
+  const line = JSON.stringify(event) + "\n";
+  fs.appendFileSync(issuesPath, line, "utf-8");
+}
+function readEventsFromFile(filePath) {
+  if (!fs.existsSync(filePath)) {
+    return [];
+  }
+  const content = fs.readFileSync(filePath, "utf-8");
+  const lines = content.split("\n").filter((line) => line.trim() !== "");
+  return lines.map((line, index) => {
+    try {
+      return JSON.parse(line);
+    } catch {
+      throw new Error(`Invalid JSON at line ${index + 1} in ${filePath}: ${line}`);
+    }
+  });
+}
+function readEvents(pebbleDir) {
+  const dir = pebbleDir ?? discoverPebbleDir();
+  if (!dir) {
+    return [];
+  }
+  const issuesPath = path.join(dir, ISSUES_FILE);
+  if (!fs.existsSync(issuesPath)) {
+    return [];
+  }
+  const content = fs.readFileSync(issuesPath, "utf-8");
+  const lines = content.split("\n").filter((line) => line.trim() !== "");
+  return lines.map((line, index) => {
+    try {
+      return JSON.parse(line);
+    } catch {
+      throw new Error(`Invalid JSON at line ${index + 1}: ${line}`);
+    }
+  });
+}
+function getConfigPath(pebbleDir) {
+  const dir = pebbleDir ?? getPebbleDir();
+  return path.join(dir, CONFIG_FILE);
+}
+function getConfig(pebbleDir) {
+  const configPath = getConfigPath(pebbleDir);
+  if (!fs.existsSync(configPath)) {
+    throw new Error("Config file not found. Initialize .pebble first.");
+  }
+  const content = fs.readFileSync(configPath, "utf-8");
+  return JSON.parse(content);
+}
+function setConfig(config, pebbleDir) {
+  const dir = pebbleDir ?? getPebbleDir();
+  const configPath = path.join(dir, CONFIG_FILE);
+  fs.writeFileSync(configPath, JSON.stringify(config, null, 2) + "\n", "utf-8");
+}
+function getOrCreatePebbleDir() {
+  const existing = discoverPebbleDir();
+  if (existing) {
+    return existing;
+  }
+  return ensurePebbleDir();
+}
+
+// src/cli/lib/state.ts
+function computeState(events) {
+  const issues = /* @__PURE__ */ new Map();
+  for (const event of events) {
+    switch (event.type) {
+      case "create": {
+        const createEvent = event;
+        const issue = {
+          id: event.issueId,
+          title: createEvent.data.title,
+          type: createEvent.data.type,
+          priority: createEvent.data.priority,
+          status: "open",
+          description: createEvent.data.description,
+          parent: createEvent.data.parent,
+          blockedBy: [],
+          comments: [],
+          createdAt: event.timestamp,
+          updatedAt: event.timestamp
+        };
+        issues.set(event.issueId, issue);
+        break;
+      }
+      case "update": {
+        const updateEvent = event;
+        const issue = issues.get(event.issueId);
+        if (issue) {
+          if (updateEvent.data.title !== void 0) {
+            issue.title = updateEvent.data.title;
+          }
+          if (updateEvent.data.type !== void 0) {
+            issue.type = updateEvent.data.type;
+          }
+          if (updateEvent.data.priority !== void 0) {
+            issue.priority = updateEvent.data.priority;
+          }
+          if (updateEvent.data.status !== void 0) {
+            issue.status = updateEvent.data.status;
+          }
+          if (updateEvent.data.description !== void 0) {
+            issue.description = updateEvent.data.description;
+          }
+          if (updateEvent.data.parent !== void 0) {
+            issue.parent = updateEvent.data.parent;
+          }
+          if (updateEvent.data.blockedBy !== void 0) {
+            issue.blockedBy = updateEvent.data.blockedBy;
+          }
+          issue.updatedAt = event.timestamp;
+        }
+        break;
+      }
+      case "close": {
+        const issue = issues.get(event.issueId);
+        if (issue) {
+          issue.status = "closed";
+          issue.updatedAt = event.timestamp;
+        }
+        break;
+      }
+      case "reopen": {
+        const issue = issues.get(event.issueId);
+        if (issue) {
+          issue.status = "open";
+          issue.updatedAt = event.timestamp;
+        }
+        break;
+      }
+      case "comment": {
+        const commentEvent = event;
+        const issue = issues.get(event.issueId);
+        if (issue) {
+          issue.comments.push(commentEvent.data);
+          issue.updatedAt = event.timestamp;
+        }
+        break;
+      }
+    }
+  }
+  return issues;
+}
+function getIssues(filters) {
+  const events = readEvents();
+  const state = computeState(events);
+  let issues = Array.from(state.values());
+  if (filters) {
+    if (filters.status !== void 0) {
+      issues = issues.filter((i) => i.status === filters.status);
+    }
+    if (filters.type !== void 0) {
+      issues = issues.filter((i) => i.type === filters.type);
+    }
+    if (filters.priority !== void 0) {
+      issues = issues.filter((i) => i.priority === filters.priority);
+    }
+    if (filters.parent !== void 0) {
+      issues = issues.filter((i) => i.parent === filters.parent);
+    }
+  }
+  return issues;
+}
+function getIssue(id) {
+  const events = readEvents();
+  const state = computeState(events);
+  return state.get(id);
+}
+function resolveId(partial) {
+  const events = readEvents();
+  const state = computeState(events);
+  const allIds = Array.from(state.keys());
+  const partialLower = partial.toLowerCase();
+  const exactMatch = allIds.find((id) => id.toLowerCase() === partialLower);
+  if (exactMatch) {
+    return exactMatch;
+  }
+  const prefixMatches = allIds.filter(
+    (id) => id.toLowerCase().startsWith(partialLower)
+  );
+  if (prefixMatches.length === 1) {
+    return prefixMatches[0];
+  }
+  if (prefixMatches.length > 1) {
+    throw new Error(
+      `Ambiguous issue ID '${partial}'. Matches: ${prefixMatches.join(", ")}`
+    );
+  }
+  const suffixMatches = allIds.filter((id) => {
+    const hyphenIndex = id.indexOf("-");
+    if (hyphenIndex === -1) return false;
+    const suffix = id.substring(hyphenIndex + 1).toLowerCase();
+    return suffix === partialLower;
+  });
+  if (suffixMatches.length === 1) {
+    return suffixMatches[0];
+  }
+  if (suffixMatches.length > 1) {
+    throw new Error(
+      `Ambiguous issue ID '${partial}'. Matches: ${suffixMatches.join(", ")}`
+    );
+  }
+  throw new Error(`Issue not found: ${partial}`);
+}
+function getReady() {
+  const events = readEvents();
+  const state = computeState(events);
+  const issues = Array.from(state.values());
+  return issues.filter((issue) => {
+    if (issue.status === "closed") {
+      return false;
+    }
+    for (const blockerId of issue.blockedBy) {
+      const blocker = state.get(blockerId);
+      if (blocker && blocker.status !== "closed") {
+        return false;
+      }
+    }
+    return true;
+  });
+}
+function getBlocked() {
+  const events = readEvents();
+  const state = computeState(events);
+  const issues = Array.from(state.values());
+  return issues.filter((issue) => {
+    if (issue.status === "closed") {
+      return false;
+    }
+    for (const blockerId of issue.blockedBy) {
+      const blocker = state.get(blockerId);
+      if (blocker && blocker.status !== "closed") {
+        return true;
+      }
+    }
+    return false;
+  });
+}
+function buildDependencyGraph() {
+  const events = readEvents();
+  const state = computeState(events);
+  const graph = /* @__PURE__ */ new Map();
+  for (const id of state.keys()) {
+    graph.set(id, []);
+  }
+  for (const [id, issue] of state) {
+    for (const blockerId of issue.blockedBy) {
+      const blockerEdges = graph.get(blockerId);
+      if (blockerEdges) {
+        blockerEdges.push(id);
+      }
+    }
+  }
+  return graph;
+}
+function detectCycle(issueId, newBlockerId) {
+  if (issueId === newBlockerId) {
+    return true;
+  }
+  const graph = buildDependencyGraph();
+  const blockerEdges = graph.get(newBlockerId) ?? [];
+  const testGraph = new Map(graph);
+  testGraph.set(newBlockerId, [...blockerEdges, issueId]);
+  const visited = /* @__PURE__ */ new Set();
+  const stack = [issueId];
+  while (stack.length > 0) {
+    const current = stack.pop();
+    if (current === newBlockerId) {
+      return true;
+    }
+    if (visited.has(current)) {
+      continue;
+    }
+    visited.add(current);
+    const edges = testGraph.get(current) ?? [];
+    for (const next of edges) {
+      if (!visited.has(next)) {
+        stack.push(next);
+      }
+    }
+  }
+  return false;
+}
+function getBlockers(issueId) {
+  const issue = getIssue(issueId);
+  if (!issue) {
+    return [];
+  }
+  const events = readEvents();
+  const state = computeState(events);
+  return issue.blockedBy.map((id) => state.get(id)).filter((i) => i !== void 0);
+}
+function getBlocking(issueId) {
+  const events = readEvents();
+  const state = computeState(events);
+  return Array.from(state.values()).filter(
+    (issue) => issue.blockedBy.includes(issueId)
+  );
+}
+function getChildren(epicId) {
+  const events = readEvents();
+  const state = computeState(events);
+  return Array.from(state.values()).filter((issue) => issue.parent === epicId);
+}
+function hasOpenChildren(epicId) {
+  const children = getChildren(epicId);
+  return children.some((child) => child.status !== "closed");
+}
+
+// src/cli/lib/output.ts
+function formatJson(data) {
+  return JSON.stringify(data, null, 2);
+}
+function formatPriority(priority) {
+  return `P${priority} (${PRIORITY_LABELS[priority]})`;
+}
+function formatStatus(status) {
+  return STATUS_LABELS[status];
+}
+function formatType(type) {
+  return TYPE_LABELS[type];
+}
+function truncate(str, maxLength) {
+  if (str.length <= maxLength) return str;
+  return str.slice(0, maxLength - 3) + "...";
+}
+function pad(str, width) {
+  return str.padEnd(width);
+}
+function formatIssuePretty(issue) {
+  const lines = [];
+  lines.push(`${issue.id} - ${issue.title}`);
+  lines.push("\u2500".repeat(60));
+  lines.push(`Type:     ${formatType(issue.type)}`);
+  lines.push(`Priority: ${formatPriority(issue.priority)}`);
+  lines.push(`Status:   ${formatStatus(issue.status)}`);
+  if (issue.parent) {
+    lines.push(`Parent:   ${issue.parent}`);
+  }
+  if (issue.description) {
+    lines.push("");
+    lines.push("Description:");
+    lines.push(issue.description);
+  }
+  if (issue.blockedBy.length > 0) {
+    lines.push("");
+    lines.push(`Blocked by: ${issue.blockedBy.join(", ")}`);
+  }
+  if (issue.comments.length > 0) {
+    lines.push("");
+    lines.push("Comments:");
+    for (const comment of issue.comments) {
+      const author = comment.author ?? "unknown";
+      const date = new Date(comment.timestamp).toLocaleString();
+      lines.push(`  [${date}] ${author}: ${comment.text}`);
+    }
+  }
+  lines.push("");
+  lines.push(`Created: ${new Date(issue.createdAt).toLocaleString()}`);
+  lines.push(`Updated: ${new Date(issue.updatedAt).toLocaleString()}`);
+  return lines.join("\n");
+}
+function formatIssueListPretty(issues) {
+  if (issues.length === 0) {
+    return "No issues found.";
+  }
+  const lines = [];
+  const idWidth = 12;
+  const typeWidth = 6;
+  const prioWidth = 4;
+  const statusWidth = 12;
+  const titleWidth = 40;
+  const header = [
+    pad("ID", idWidth),
+    pad("Type", typeWidth),
+    pad("Pri", prioWidth),
+    pad("Status", statusWidth),
+    pad("Title", titleWidth)
+  ].join(" \u2502 ");
+  lines.push(header);
+  lines.push("\u2500".repeat(header.length));
+  for (const issue of issues) {
+    const row = [
+      pad(issue.id, idWidth),
+      pad(issue.type, typeWidth),
+      pad(`P${issue.priority}`, prioWidth),
+      pad(issue.status, statusWidth),
+      truncate(issue.title, titleWidth)
+    ].join(" \u2502 ");
+    lines.push(row);
+  }
+  lines.push("");
+  lines.push(`Total: ${issues.length} issue(s)`);
+  return lines.join("\n");
+}
+function formatDepsPretty(issueId, blockedBy, blocking) {
+  const lines = [];
+  lines.push(`Dependencies for ${issueId}`);
+  lines.push("\u2500".repeat(40));
+  lines.push("");
+  lines.push("Blocked by:");
+  if (blockedBy.length === 0) {
+    lines.push("  (none)");
+  } else {
+    for (const issue of blockedBy) {
+      const status = issue.status === "closed" ? "\u2713" : "\u25CB";
+      lines.push(`  ${status} ${issue.id} - ${truncate(issue.title, 30)}`);
+    }
+  }
+  lines.push("");
+  lines.push("Blocking:");
+  if (blocking.length === 0) {
+    lines.push("  (none)");
+  } else {
+    for (const issue of blocking) {
+      lines.push(`  \u25CB ${issue.id} - ${truncate(issue.title, 30)}`);
+    }
+  }
+  return lines.join("\n");
+}
+function formatError(error) {
+  const message = error instanceof Error ? error.message : error;
+  return JSON.stringify({ error: message });
+}
+function formatErrorPretty(error) {
+  const message = error instanceof Error ? error.message : error;
+  return `Error: ${message}`;
+}
+function outputIssue(issue, pretty) {
+  if (pretty) {
+    console.log(formatIssuePretty(issue));
+  } else {
+    console.log(formatJson(issue));
+  }
+}
+function outputMutationSuccess(id, pretty) {
+  if (pretty) {
+    console.log(`\u2713 ${id}`);
+  } else {
+    console.log(JSON.stringify({ id, success: true }));
+  }
+}
+function outputIssueList(issues, pretty) {
+  if (pretty) {
+    console.log(formatIssueListPretty(issues));
+  } else {
+    console.log(formatJson(issues));
+  }
+}
+function outputError(error, pretty) {
+  if (pretty) {
+    console.error(formatErrorPretty(error));
+  } else {
+    console.error(formatError(error));
+  }
+  process.exit(1);
+}
+
+// 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) => {
+    const pretty = program2.opts().pretty ?? false;
+    try {
+      const type = options.type;
+      if (!ISSUE_TYPES.includes(type)) {
+        throw new Error(`Invalid type: ${type}. Must be one of: ${ISSUE_TYPES.join(", ")}`);
+      }
+      const priority = parseInt(options.priority, 10);
+      if (!PRIORITIES.includes(priority)) {
+        throw new Error(`Invalid priority: ${options.priority}. Must be 0-4`);
+      }
+      const pebbleDir = getOrCreatePebbleDir();
+      const config = getConfig(pebbleDir);
+      let parentId;
+      if (options.parent) {
+        parentId = resolveId(options.parent);
+        const parent = getIssue(parentId);
+        if (!parent) {
+          throw new Error(`Parent issue not found: ${options.parent}`);
+        }
+        if (parent.type !== "epic") {
+          throw new Error(`Parent must be an epic, got: ${parent.type}`);
+        }
+        if (parent.status === "closed") {
+          throw new Error(`Cannot add children to closed epic: ${parentId}`);
+        }
+      }
+      const id = generateId(config.prefix);
+      const timestamp = (/* @__PURE__ */ new Date()).toISOString();
+      const event = {
+        type: "create",
+        issueId: id,
+        timestamp,
+        data: {
+          title,
+          type,
+          priority,
+          description: options.description,
+          parent: parentId
+        }
+      };
+      appendEvent(event, pebbleDir);
+      outputMutationSuccess(id, pretty);
+    } catch (error) {
+      outputError(error, pretty);
+    }
+  });
+}
+
+// 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) => {
+    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 data = {};
+      let hasChanges = false;
+      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(", ")}`);
+        }
+        data.status = status;
+        hasChanges = true;
+      }
+      if (options.priority !== void 0) {
+        const priority = parseInt(options.priority, 10);
+        if (!PRIORITIES.includes(priority)) {
+          throw new Error(`Invalid priority: ${options.priority}. Must be 0-4`);
+        }
+        data.priority = priority;
+        hasChanges = true;
+      }
+      if (options.title !== void 0) {
+        data.title = options.title;
+        hasChanges = true;
+      }
+      if (options.description !== void 0) {
+        data.description = options.description;
+        hasChanges = true;
+      }
+      if (!hasChanges) {
+        throw new Error("No changes specified. Use --status, --priority, --title, or --description");
+      }
+      const results = [];
+      for (const id of allIds) {
+        try {
+          const resolvedId = resolveId(id);
+          const issue = getIssue(resolvedId);
+          if (!issue) {
+            results.push({ id, success: false, error: `Issue not found: ${id}` });
+            continue;
+          }
+          const event = {
+            type: "update",
+            issueId: resolvedId,
+            timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+            data
+          };
+          appendEvent(event, 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) {
+          outputMutationSuccess(result.id, pretty);
+        } else {
+          throw new Error(result.error || "Unknown error");
+        }
+      } else {
+        if (pretty) {
+          for (const result of results) {
+            if (result.success) {
+              console.log(`\u2713 ${result.id}`);
+            } else {
+              console.log(`\u2717 ${result.id}: ${result.error}`);
+            }
+          }
+        } else {
+          console.log(formatJson(results.map((r) => ({
+            id: r.id,
+            success: r.success,
+            ...r.error && { error: r.error }
+          }))));
+        }
+      }
+    } catch (error) {
+      outputError(error, pretty);
+    }
+  });
+}
+
+// src/cli/commands/close.ts
+function closeCommand(program2) {
+  program2.command("close <ids...>").description("Close issues. Supports multiple IDs.").option("--reason <reason>", "Reason for closing").option("--comment <text>", "Add a comment before closing").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 = [];
+      for (const id of allIds) {
+        try {
+          const resolvedId = resolveId(id);
+          const issue = getIssue(resolvedId);
+          if (!issue) {
+            results.push({ id, success: false, error: `Issue not found: ${id}` });
+            continue;
+          }
+          if (issue.status === "closed") {
+            results.push({ id: resolvedId, success: false, error: `Issue is already closed: ${resolvedId}` });
+            continue;
+          }
+          if (issue.type === "epic" && hasOpenChildren(resolvedId)) {
+            results.push({ id: resolvedId, success: false, error: `Cannot close epic with open children: ${resolvedId}` });
+            continue;
+          }
+          const timestamp = (/* @__PURE__ */ new Date()).toISOString();
+          if (options.comment) {
+            const commentEvent = {
+              type: "comment",
+              issueId: resolvedId,
+              timestamp,
+              data: {
+                text: options.comment,
+                timestamp
+              }
+            };
+            appendEvent(commentEvent, pebbleDir);
+          }
+          const closeEvent = {
+            type: "close",
+            issueId: resolvedId,
+            timestamp,
+            data: {
+              reason: options.reason
+            }
+          };
+          appendEvent(closeEvent, 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) {
+          outputMutationSuccess(result.id, pretty);
+        } else {
+          throw new Error(result.error || "Unknown error");
+        }
+      } else {
+        if (pretty) {
+          for (const result of results) {
+            if (result.success) {
+              console.log(`\u2713 ${result.id}`);
+            } else {
+              console.log(`\u2717 ${result.id}: ${result.error}`);
+            }
+          }
+        } else {
+          console.log(formatJson(results.map((r) => ({
+            id: r.id,
+            success: r.success,
+            ...r.error && { error: r.error }
+          }))));
+        }
+      }
+    } catch (error) {
+      outputError(error, pretty);
+    }
+  });
+}
+
+// src/cli/commands/reopen.ts
+function reopenCommand(program2) {
+  program2.command("reopen <id>").description("Reopen a closed issue").option("--reason <reason>", "Reason for reopening").action(async (id, options) => {
+    const pretty = program2.opts().pretty ?? false;
+    try {
+      const pebbleDir = getOrCreatePebbleDir();
+      const resolvedId = resolveId(id);
+      const issue = getIssue(resolvedId);
+      if (!issue) {
+        throw new Error(`Issue not found: ${id}`);
+      }
+      if (issue.status !== "closed") {
+        throw new Error(`Issue is not closed: ${resolvedId} (status: ${issue.status})`);
+      }
+      const event = {
+        type: "reopen",
+        issueId: resolvedId,
+        timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+        data: {
+          reason: options.reason
+        }
+      };
+      appendEvent(event, pebbleDir);
+      outputMutationSuccess(resolvedId, pretty);
+    } 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) => {
+    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 = [];
+      for (const id of allIds) {
+        try {
+          const resolvedId = resolveId(id);
+          const issue = getIssue(resolvedId);
+          if (!issue) {
+            results.push({ id, success: false, error: `Issue not found: ${id}` });
+            continue;
+          }
+          if (issue.status === "in_progress") {
+            results.push({ id: resolvedId, success: true });
+            continue;
+          }
+          if (issue.status === "closed") {
+            results.push({ id: resolvedId, success: false, error: `Cannot claim closed issue: ${resolvedId}` });
+            continue;
+          }
+          const event = {
+            type: "update",
+            issueId: resolvedId,
+            timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+            data: {
+              status: "in_progress"
+            }
+          };
+          appendEvent(event, 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) {
+          outputMutationSuccess(result.id, pretty);
+        } else {
+          throw new Error(result.error || "Unknown error");
+        }
+      } else {
+        if (pretty) {
+          for (const result of results) {
+            if (result.success) {
+              console.log(`\u2713 ${result.id}`);
+            } else {
+              console.log(`\u2717 ${result.id}: ${result.error}`);
+            }
+          }
+        } else {
+          console.log(formatJson(results.map((r) => ({
+            id: r.id,
+            success: r.success,
+            ...r.error && { error: r.error }
+          }))));
+        }
+      }
+    } catch (error) {
+      outputError(error, pretty);
+    }
+  });
+}
+
+// src/cli/commands/list.ts
+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 {
+      const filters = {};
+      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(", ")}`);
+        }
+        filters.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(", ")}`);
+        }
+        filters.type = type;
+      }
+      if (options.priority !== void 0) {
+        const priority = parseInt(options.priority, 10);
+        if (!PRIORITIES.includes(priority)) {
+          throw new Error(`Invalid priority: ${options.priority}. Must be 0-4`);
+        }
+        filters.priority = priority;
+      }
+      if (options.parent !== void 0) {
+        filters.parent = resolveId(options.parent);
+      }
+      const issues = getIssues(filters);
+      outputIssueList(issues, pretty);
+    } catch (error) {
+      outputError(error, pretty);
+    }
+  });
+}
+
+// src/cli/commands/show.ts
+function showCommand(program2) {
+  program2.command("show <id>").description("Show issue details").action(async (id) => {
+    const pretty = program2.opts().pretty ?? false;
+    try {
+      const resolvedId = resolveId(id);
+      const issue = getIssue(resolvedId);
+      if (!issue) {
+        throw new Error(`Issue not found: ${id}`);
+      }
+      outputIssue(issue, pretty);
+    } catch (error) {
+      outputError(error, pretty);
+    }
+  });
+}
+
+// src/cli/commands/ready.ts
+function readyCommand(program2) {
+  program2.command("ready").description("Show issues ready for work (no open blockers)").action(async () => {
+    const pretty = program2.opts().pretty ?? false;
+    try {
+      const issues = getReady();
+      outputIssueList(issues, pretty);
+    } catch (error) {
+      outputError(error, pretty);
+    }
+  });
+}
+
+// src/cli/commands/blocked.ts
+function blockedCommand(program2) {
+  program2.command("blocked").description("Show blocked issues (have open blockers)").action(async () => {
+    const pretty = program2.opts().pretty ?? false;
+    try {
+      const issues = getBlocked();
+      outputIssueList(issues, pretty);
+    } catch (error) {
+      outputError(error, pretty);
+    }
+  });
+}
+
+// src/cli/commands/dep.ts
+function depCommand(program2) {
+  const dep = program2.command("dep").description("Manage dependencies");
+  dep.command("add <id> <blockerId>").description("Add a blocking dependency").action(async (id, blockerId) => {
+    const pretty = program2.opts().pretty ?? false;
+    try {
+      const pebbleDir = getOrCreatePebbleDir();
+      const resolvedId = resolveId(id);
+      const resolvedBlockerId = resolveId(blockerId);
+      const issue = getIssue(resolvedId);
+      if (!issue) {
+        throw new Error(`Issue not found: ${id}`);
+      }
+      const blocker = getIssue(resolvedBlockerId);
+      if (!blocker) {
+        throw new Error(`Blocker issue not found: ${blockerId}`);
+      }
+      if (resolvedId === resolvedBlockerId) {
+        throw new Error("Cannot add self as blocker");
+      }
+      if (issue.blockedBy.includes(resolvedBlockerId)) {
+        throw new Error(`Dependency already exists: ${resolvedId} is blocked by ${resolvedBlockerId}`);
+      }
+      if (detectCycle(resolvedId, resolvedBlockerId)) {
+        throw new Error(`Adding this dependency would create a cycle`);
+      }
+      const event = {
+        type: "update",
+        issueId: resolvedId,
+        timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+        data: {
+          blockedBy: [...issue.blockedBy, resolvedBlockerId]
+        }
+      };
+      appendEvent(event, pebbleDir);
+      outputMutationSuccess(resolvedId, pretty);
+    } catch (error) {
+      outputError(error, pretty);
+    }
+  });
+  dep.command("remove <id> <blockerId>").description("Remove a blocking dependency").action(async (id, blockerId) => {
+    const pretty = program2.opts().pretty ?? false;
+    try {
+      const pebbleDir = getOrCreatePebbleDir();
+      const resolvedId = resolveId(id);
+      const resolvedBlockerId = resolveId(blockerId);
+      const issue = getIssue(resolvedId);
+      if (!issue) {
+        throw new Error(`Issue not found: ${id}`);
+      }
+      if (!issue.blockedBy.includes(resolvedBlockerId)) {
+        throw new Error(`Dependency does not exist: ${resolvedId} is not blocked by ${resolvedBlockerId}`);
+      }
+      const newBlockedBy = issue.blockedBy.filter((b) => b !== resolvedBlockerId);
+      const event = {
+        type: "update",
+        issueId: resolvedId,
+        timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+        data: {
+          blockedBy: newBlockedBy
+        }
+      };
+      appendEvent(event, pebbleDir);
+      outputMutationSuccess(resolvedId, pretty);
+    } catch (error) {
+      outputError(error, pretty);
+    }
+  });
+  dep.command("list <id>").description("List dependencies for an issue").action(async (id) => {
+    const pretty = program2.opts().pretty ?? false;
+    try {
+      const resolvedId = resolveId(id);
+      const issue = getIssue(resolvedId);
+      if (!issue) {
+        throw new Error(`Issue not found: ${id}`);
+      }
+      const blockedBy = getBlockers(resolvedId);
+      const blocking = getBlocking(resolvedId);
+      if (pretty) {
+        console.log(formatDepsPretty(resolvedId, blockedBy, blocking));
+      } else {
+        console.log(formatJson({
+          issueId: resolvedId,
+          blockedBy: blockedBy.map((i) => ({ id: i.id, title: i.title, status: i.status })),
+          blocking: blocking.map((i) => ({ id: i.id, title: i.title, status: i.status }))
+        }));
+      }
+    } catch (error) {
+      outputError(error, pretty);
+    }
+  });
+  dep.command("tree <id>").description("Show dependency tree").action(async (id) => {
+    const pretty = program2.opts().pretty ?? false;
+    try {
+      const resolvedId = resolveId(id);
+      const issue = getIssue(resolvedId);
+      if (!issue) {
+        throw new Error(`Issue not found: ${id}`);
+      }
+      const events = readEvents();
+      const state = computeState(events);
+      const visited = /* @__PURE__ */ new Set();
+      const tree = buildDepTree(resolvedId, visited, 0, state);
+      if (pretty) {
+        console.log(formatDepTree(tree));
+      } else {
+        console.log(formatJson(tree));
+      }
+    } catch (error) {
+      outputError(error, pretty);
+    }
+  });
+}
+function buildDepTree(issueId, visited, depth, state) {
+  if (visited.has(issueId)) {
+    return null;
+  }
+  visited.add(issueId);
+  const issue = state.get(issueId);
+  if (!issue) {
+    return null;
+  }
+  const blockedBy = [];
+  for (const blockerId of issue.blockedBy) {
+    const child = buildDepTree(blockerId, visited, depth + 1, state);
+    if (child) {
+      blockedBy.push(child);
+    }
+  }
+  return {
+    id: issue.id,
+    title: issue.title,
+    status: issue.status,
+    depth,
+    blockedBy
+  };
+}
+function formatDepTree(node, prefix = "", isRoot = true) {
+  if (!node) {
+    return "";
+  }
+  const lines = [];
+  const statusIcon = node.status === "closed" ? "\u2713" : "\u25CB";
+  if (isRoot) {
+    lines.push(`${statusIcon} ${node.id} - ${node.title}`);
+  }
+  for (let i = 0; i < node.blockedBy.length; i++) {
+    const child = node.blockedBy[i];
+    const isLast = i === node.blockedBy.length - 1;
+    const connector = isLast ? "\u2514\u2500 " : "\u251C\u2500 ";
+    const childPrefix = prefix + (isLast ? "   " : "\u2502  ");
+    const childStatusIcon = child.status === "closed" ? "\u2713" : "\u25CB";
+    lines.push(`${prefix}${connector}${childStatusIcon} ${child.id} - ${child.title}`);
+    if (child.blockedBy.length > 0) {
+      lines.push(formatDepTree(child, childPrefix, false));
+    }
+  }
+  return lines.join("\n");
+}
+
+// src/cli/commands/comments.ts
+function commentsCommand(program2) {
+  const comments = program2.command("comments").description("Manage comments");
+  comments.command("add <id> <text>").description("Add a comment to an issue").action(async (id, text) => {
+    const pretty = program2.opts().pretty ?? false;
+    try {
+      const pebbleDir = getOrCreatePebbleDir();
+      const resolvedId = resolveId(id);
+      const issue = getIssue(resolvedId);
+      if (!issue) {
+        throw new Error(`Issue not found: ${id}`);
+      }
+      const timestamp = (/* @__PURE__ */ new Date()).toISOString();
+      const event = {
+        type: "comment",
+        issueId: resolvedId,
+        timestamp,
+        data: {
+          text,
+          timestamp
+        }
+      };
+      appendEvent(event, pebbleDir);
+      outputMutationSuccess(resolvedId, pretty);
+    } catch (error) {
+      outputError(error, pretty);
+    }
+  });
+}
+
+// src/cli/commands/graph.ts
+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 {
+      let issues;
+      if (options.root) {
+        const rootId = resolveId(options.root);
+        const rootIssue = getIssue(rootId);
+        if (!rootIssue) {
+          throw new Error(`Issue not found: ${options.root}`);
+        }
+        issues = getSubtree(rootId);
+      } else {
+        issues = getIssues({});
+      }
+      if (pretty) {
+        console.log(formatGraphPretty(issues));
+      } else {
+        console.log(formatJson({
+          nodes: issues.map((i) => ({
+            id: i.id,
+            title: i.title,
+            status: i.status,
+            blockedBy: i.blockedBy
+          }))
+        }));
+      }
+    } catch (error) {
+      outputError(error, pretty);
+    }
+  });
+}
+function getSubtree(rootId) {
+  const allIssues = getIssues({});
+  const issueMap = new Map(allIssues.map((i) => [i.id, i]));
+  const neighborhood = /* @__PURE__ */ new Set();
+  function traverseUpstream(id) {
+    if (neighborhood.has(id)) return;
+    neighborhood.add(id);
+    const issue = issueMap.get(id);
+    if (issue) {
+      for (const blockerId of issue.blockedBy) {
+        traverseUpstream(blockerId);
+      }
+      if (issue.parent) {
+        traverseUpstream(issue.parent);
+      }
+    }
+  }
+  function traverseDownstream(id) {
+    if (neighborhood.has(id)) return;
+    neighborhood.add(id);
+    for (const issue of allIssues) {
+      if (issue.blockedBy.includes(id)) {
+        traverseDownstream(issue.id);
+      }
+      if (issue.parent === id) {
+        traverseDownstream(issue.id);
+      }
+    }
+  }
+  traverseUpstream(rootId);
+  traverseDownstream(rootId);
+  return allIssues.filter((i) => neighborhood.has(i.id));
+}
+function formatGraphPretty(issues) {
+  if (issues.length === 0) {
+    return "No issues found.";
+  }
+  const lines = [];
+  lines.push("Dependency Graph");
+  lines.push("================");
+  lines.push("");
+  const blockedByMap = /* @__PURE__ */ new Map();
+  const blockingMap = /* @__PURE__ */ new Map();
+  const issueMap = /* @__PURE__ */ new Map();
+  for (const issue of issues) {
+    issueMap.set(issue.id, issue);
+    blockedByMap.set(issue.id, issue.blockedBy);
+    for (const blockerId of issue.blockedBy) {
+      if (!blockingMap.has(blockerId)) {
+        blockingMap.set(blockerId, []);
+      }
+      blockingMap.get(blockerId).push(issue.id);
+    }
+  }
+  const levels = /* @__PURE__ */ new Map();
+  const visited = /* @__PURE__ */ new Set();
+  function calculateLevel(id) {
+    if (levels.has(id)) return levels.get(id);
+    if (visited.has(id)) return 0;
+    visited.add(id);
+    const blockedBy = blockedByMap.get(id) || [];
+    let maxBlockerLevel = -1;
+    for (const blockerId of blockedBy) {
+      const blockerLevel = calculateLevel(blockerId);
+      maxBlockerLevel = Math.max(maxBlockerLevel, blockerLevel);
+    }
+    const level = maxBlockerLevel + 1;
+    levels.set(id, level);
+    return level;
+  }
+  for (const issue of issues) {
+    calculateLevel(issue.id);
+  }
+  const byLevel = /* @__PURE__ */ new Map();
+  for (const issue of issues) {
+    const level = levels.get(issue.id) || 0;
+    if (!byLevel.has(level)) {
+      byLevel.set(level, []);
+    }
+    byLevel.get(level).push(issue);
+  }
+  const maxLevel = Math.max(...Array.from(levels.values()));
+  for (let level = 0; level <= maxLevel; level++) {
+    const levelIssues = byLevel.get(level) || [];
+    if (levelIssues.length === 0) continue;
+    lines.push(`Level ${level}:`);
+    for (const issue of levelIssues) {
+      const statusIcon = issue.status === "closed" ? "\u2713" : "\u25CB";
+      const blockers = issue.blockedBy.length > 0 ? ` \u2190 [${issue.blockedBy.join(", ")}]` : "";
+      lines.push(`  ${statusIcon} ${issue.id} - ${issue.title}${blockers}`);
+    }
+    lines.push("");
+  }
+  return lines.join("\n");
+}
+
+// src/cli/commands/ui.ts
+import express from "express";
+import cors from "cors";
+import { fileURLToPath } from "url";
+import path2 from "path";
+import fs2 from "fs";
+import net from "net";
+import open from "open";
+import chokidar from "chokidar";
+function isPortAvailable(port) {
+  return new Promise((resolve3) => {
+    const server = net.createServer();
+    server.once("error", () => resolve3(false));
+    server.once("listening", () => {
+      server.close();
+      resolve3(true);
+    });
+    server.listen(port);
+  });
+}
+async function findAvailablePort(startPort, maxAttempts = 10) {
+  for (let i = 0; i < maxAttempts; i++) {
+    const port = startPort + i;
+    if (await isPortAvailable(port)) {
+      return port;
+    }
+  }
+  throw new Error(`No available port found (tried ${startPort}-${startPort + maxAttempts - 1})`);
+}
+function readEventsFromFiles(filePaths) {
+  const allEvents = [];
+  for (const filePath of filePaths) {
+    const events = readEventsFromFile(filePath);
+    for (const event of events) {
+      allEvents.push({ ...event, _source: filePath });
+    }
+  }
+  return allEvents;
+}
+function mergeIssuesFromFiles(filePaths) {
+  const merged = /* @__PURE__ */ new Map();
+  for (const filePath of filePaths) {
+    const events = readEventsFromFile(filePath);
+    const state = computeState(events);
+    for (const [id, issue] of state) {
+      const existing = merged.get(id);
+      if (!existing) {
+        merged.set(id, { issue, sources: /* @__PURE__ */ new Set([filePath]) });
+      } else {
+        existing.sources.add(filePath);
+        if (new Date(issue.updatedAt) > new Date(existing.issue.updatedAt)) {
+          merged.set(id, { issue, sources: existing.sources });
+        }
+      }
+    }
+  }
+  return Array.from(merged.values()).map(({ issue, sources }) => ({
+    ...issue,
+    _sources: Array.from(sources)
+  }));
+}
+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) => {
+    const pretty = program2.opts().pretty ?? false;
+    try {
+      let issueFiles = [];
+      if (options.files) {
+        issueFiles = options.files.split(",").map((p) => p.trim()).filter(Boolean);
+        if (issueFiles.length === 0) {
+          console.error("Error: --files option requires at least one path");
+          process.exit(1);
+        }
+        issueFiles = issueFiles.map((p) => path2.resolve(process.cwd(), p));
+        console.log(`Multi-worktree mode: watching ${issueFiles.length} file(s)`);
+        for (const f of issueFiles) {
+          console.log(`  - ${f}`);
+        }
+      } else {
+        const pebbleDir = getOrCreatePebbleDir();
+        issueFiles = [path2.join(pebbleDir, "issues.jsonl")];
+      }
+      if (!options.files) {
+        getOrCreatePebbleDir();
+      }
+      const app = express();
+      app.use(cors());
+      app.use(express.json());
+      const isMultiWorktree = () => issueFiles.length > 1;
+      app.get("/api/sources", (_req, res) => {
+        try {
+          res.json({ files: issueFiles, isMultiWorktree: isMultiWorktree() });
+        } catch (error) {
+          res.status(500).json({ error: error.message });
+        }
+      });
+      app.post("/api/sources", (req, res) => {
+        try {
+          const { path: filePath } = req.body;
+          if (!filePath || typeof filePath !== "string") {
+            res.status(400).json({ error: "path is required" });
+            return;
+          }
+          const resolved = path2.resolve(process.cwd(), filePath);
+          if (!fs2.existsSync(resolved)) {
+            res.status(400).json({ error: `File not found: ${filePath}` });
+            return;
+          }
+          if (issueFiles.includes(resolved)) {
+            res.status(400).json({ error: "File already being watched" });
+            return;
+          }
+          issueFiles.push(resolved);
+          watcher.add(resolved);
+          console.log(`Added source: ${resolved}`);
+          res.json({ files: issueFiles, isMultiWorktree: isMultiWorktree() });
+        } catch (error) {
+          res.status(500).json({ error: error.message });
+        }
+      });
+      app.delete("/api/sources/:index", (req, res) => {
+        try {
+          const index = parseInt(req.params.index, 10);
+          if (isNaN(index) || index < 0 || index >= issueFiles.length) {
+            res.status(400).json({ error: `Invalid index: ${req.params.index}` });
+            return;
+          }
+          if (issueFiles.length === 1) {
+            res.status(400).json({ error: "Cannot remove the last source file" });
+            return;
+          }
+          const removed = issueFiles.splice(index, 1)[0];
+          watcher.unwatch(removed);
+          console.log(`Removed source: ${removed}`);
+          res.json({ files: issueFiles, isMultiWorktree: isMultiWorktree() });
+        } catch (error) {
+          res.status(500).json({ error: error.message });
+        }
+      });
+      app.get("/api/issues", (_req, res) => {
+        try {
+          if (isMultiWorktree()) {
+            const issues = mergeIssuesFromFiles(issueFiles);
+            res.json(issues);
+          } else {
+            const issues = getIssues({});
+            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);
+          }
+        } catch (error) {
+          res.status(500).json({ error: error.message });
+        }
+      });
+      const sseClients = /* @__PURE__ */ new Set();
+      let eventCounter = 0;
+      app.get("/api/events/stream", (req, res) => {
+        res.setHeader("Content-Type", "text/event-stream");
+        res.setHeader("Cache-Control", "no-cache");
+        res.setHeader("Connection", "keep-alive");
+        res.flushHeaders();
+        sseClients.add(res);
+        eventCounter++;
+        res.write(`id: ${eventCounter}
+data: {"type":"connected"}
+
+`);
+        req.on("close", () => {
+          sseClients.delete(res);
+        });
+      });
+      const heartbeatInterval = setInterval(() => {
+        for (const client of sseClients) {
+          client.write(": heartbeat\n\n");
+        }
+      }, 3e4);
+      const watcher = chokidar.watch(issueFiles, {
+        persistent: true,
+        ignoreInitial: true
+      });
+      watcher.on("change", () => {
+        eventCounter++;
+        const message = JSON.stringify({ type: "change", timestamp: (/* @__PURE__ */ new Date()).toISOString() });
+        for (const client of sseClients) {
+          client.write(`id: ${eventCounter}
+data: ${message}
+
+`);
+        }
+      });
+      const shutdown = () => {
+        clearInterval(heartbeatInterval);
+        watcher.close();
+        process.exit(0);
+      };
+      process.on("SIGTERM", shutdown);
+      process.on("SIGINT", shutdown);
+      app.post("/api/issues", (req, res) => {
+        try {
+          let targetFile = null;
+          if (isMultiWorktree() && req.query.target !== void 0) {
+            const targetIndex = parseInt(req.query.target, 10);
+            if (isNaN(targetIndex) || targetIndex < 0 || targetIndex >= issueFiles.length) {
+              res.status(400).json({ error: `Invalid target index: ${req.query.target}` });
+              return;
+            }
+            targetFile = issueFiles[targetIndex];
+          }
+          const pebbleDir = targetFile ? path2.dirname(targetFile) : getOrCreatePebbleDir();
+          const config = getConfig(pebbleDir);
+          const { title, type, priority, description, parent } = req.body;
+          if (!title || typeof title !== "string") {
+            res.status(400).json({ error: "Title is required" });
+            return;
+          }
+          const issueType = type || "task";
+          if (!ISSUE_TYPES.includes(issueType)) {
+            res.status(400).json({ error: `Invalid type. Must be one of: ${ISSUE_TYPES.join(", ")}` });
+            return;
+          }
+          const issuePriority = priority ?? 2;
+          if (!PRIORITIES.includes(issuePriority)) {
+            res.status(400).json({ error: "Priority must be 0-4" });
+            return;
+          }
+          if (parent) {
+            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 (parentIssue.status === "closed") {
+              res.status(400).json({ error: "Cannot add children to a closed epic" });
+              return;
+            }
+          }
+          const issueId = generateId(config.prefix);
+          const timestamp = (/* @__PURE__ */ new Date()).toISOString();
+          const event = {
+            type: "create",
+            issueId,
+            timestamp,
+            data: {
+              title,
+              type: issueType,
+              priority: issuePriority,
+              description,
+              parent
+            }
+          };
+          appendEvent(event, pebbleDir);
+          const issue = getIssue(issueId);
+          res.status(201).json(issue);
+        } catch (error) {
+          res.status(500).json({ error: error.message });
+        }
+      });
+      app.post("/api/issues/bulk/close", (req, res) => {
+        try {
+          const pebbleDir = getOrCreatePebbleDir();
+          const { ids } = req.body;
+          if (!ids || !Array.isArray(ids) || ids.length === 0) {
+            res.status(400).json({ error: "ids array is required" });
+            return;
+          }
+          const results = [];
+          for (const rawId of ids) {
+            try {
+              const issueId = resolveId(rawId);
+              const issue = getIssue(issueId);
+              if (!issue) {
+                results.push({ id: rawId, success: false, error: `Issue not found: ${rawId}` });
+                continue;
+              }
+              if (issue.status === "closed") {
+                results.push({ id: issueId, success: true });
+                continue;
+              }
+              if (issue.type === "epic" && hasOpenChildren(issueId)) {
+                results.push({ id: issueId, success: false, error: "Cannot close epic with open children" });
+                continue;
+              }
+              const event = {
+                issueId,
+                timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+                type: "close",
+                data: { reason: "Bulk close" }
+              };
+              appendEvent(event, pebbleDir);
+              results.push({ id: issueId, success: true });
+            } catch (error) {
+              results.push({ id: rawId, success: false, error: error.message });
+            }
+          }
+          res.json({ results });
+        } catch (error) {
+          res.status(500).json({ error: error.message });
+        }
+      });
+      app.post("/api/issues/bulk/update", (req, res) => {
+        try {
+          const pebbleDir = getOrCreatePebbleDir();
+          const { ids, updates } = req.body;
+          if (!ids || !Array.isArray(ids) || ids.length === 0) {
+            res.status(400).json({ error: "ids array is required" });
+            return;
+          }
+          if (!updates || Object.keys(updates).length === 0) {
+            res.status(400).json({ error: "updates object is required" });
+            return;
+          }
+          if (updates.status) {
+            const validStatuses = ["open", "in_progress", "blocked"];
+            if (!validStatuses.includes(updates.status)) {
+              res.status(400).json({
+                error: `Invalid status: ${updates.status}. Use close endpoint to close issues.`
+              });
+              return;
+            }
+          }
+          if (updates.priority !== void 0) {
+            if (typeof updates.priority !== "number" || updates.priority < 0 || updates.priority > 4) {
+              res.status(400).json({ error: "Priority must be 0-4" });
+              return;
+            }
+          }
+          const results = [];
+          for (const rawId of ids) {
+            try {
+              const issueId = resolveId(rawId);
+              const issue = getIssue(issueId);
+              if (!issue) {
+                results.push({ id: rawId, success: false, error: `Issue not found: ${rawId}` });
+                continue;
+              }
+              const event = {
+                issueId,
+                timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+                type: "update",
+                data: {
+                  ...updates.status && { status: updates.status },
+                  ...updates.priority !== void 0 && { priority: updates.priority }
+                }
+              };
+              appendEvent(event, pebbleDir);
+              results.push({ id: issueId, success: true });
+            } catch (error) {
+              results.push({ id: rawId, success: false, error: error.message });
+            }
+          }
+          res.json({ results });
+        } catch (error) {
+          res.status(500).json({ error: error.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;
+          }
+          const { title, type, priority, status, description, parent } = req.body;
+          const updates = {};
+          if (title !== void 0) {
+            if (typeof title !== "string" || title.trim() === "") {
+              res.status(400).json({ error: "Title cannot be empty" });
+              return;
+            }
+            updates.title = title;
+          }
+          if (type !== void 0) {
+            if (!ISSUE_TYPES.includes(type)) {
+              res.status(400).json({ error: `Invalid type. Must be one of: ${ISSUE_TYPES.join(", ")}` });
+              return;
+            }
+            updates.type = type;
+          }
+          if (priority !== void 0) {
+            if (!PRIORITIES.includes(priority)) {
+              res.status(400).json({ error: "Priority must be 0-4" });
+              return;
+            }
+            updates.priority = priority;
+          }
+          if (status !== void 0) {
+            if (!STATUSES.includes(status)) {
+              res.status(400).json({ error: `Invalid status. Must be one of: ${STATUSES.join(", ")}` });
+              return;
+            }
+            updates.status = status;
+          }
+          if (description !== void 0) {
+            updates.description = description;
+          }
+          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;
+              }
+            }
+            updates.parent = parent;
+          }
+          if (Object.keys(updates).length === 0) {
+            res.status(400).json({ error: "No valid updates provided" });
+            return;
+          }
+          const timestamp = (/* @__PURE__ */ new Date()).toISOString();
+          const event = {
+            type: "update",
+            issueId,
+            timestamp,
+            data: updates
+          };
+          appendEvent(event, pebbleDir);
+          const updatedIssue = getIssue(issueId);
+          res.json(updatedIssue);
+        } 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;
+          }
+          if (issue.status === "closed") {
+            res.status(400).json({ error: "Issue is already closed" });
+            return;
+          }
+          if (issue.type === "epic" && hasOpenChildren(issueId)) {
+            res.status(400).json({ error: "Cannot close epic with open children" });
+            return;
+          }
+          const { reason } = req.body;
+          const timestamp = (/* @__PURE__ */ new Date()).toISOString();
+          const event = {
+            type: "close",
+            issueId,
+            timestamp,
+            data: { reason }
+          };
+          appendEvent(event, pebbleDir);
+          const closedIssue = getIssue(issueId);
+          res.json(closedIssue);
+        } 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;
+          }
+          if (issue.status !== "closed") {
+            res.status(400).json({ error: "Issue is not closed" });
+            return;
+          }
+          const { reason } = req.body;
+          const timestamp = (/* @__PURE__ */ new Date()).toISOString();
+          const event = {
+            type: "reopen",
+            issueId,
+            timestamp,
+            data: { reason }
+          };
+          appendEvent(event, pebbleDir);
+          const reopenedIssue = getIssue(issueId);
+          res.json(reopenedIssue);
+        } 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;
+          }
+          const { text, author } = req.body;
+          if (!text || typeof text !== "string" || text.trim() === "") {
+            res.status(400).json({ error: "Comment text is required" });
+            return;
+          }
+          const timestamp = (/* @__PURE__ */ new Date()).toISOString();
+          const event = {
+            type: "comment",
+            issueId,
+            timestamp,
+            data: {
+              text,
+              timestamp,
+              author
+            }
+          };
+          appendEvent(event, pebbleDir);
+          const updatedIssue = getIssue(issueId);
+          res.json(updatedIssue);
+        } 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;
+          }
+          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;
+          }
+          if (issue.blockedBy.includes(resolvedBlockerId)) {
+            res.status(400).json({ error: "Dependency already exists" });
+            return;
+          }
+          if (detectCycle(issueId, resolvedBlockerId)) {
+            res.status(400).json({ error: "Adding this dependency would create a cycle" });
+            return;
+          }
+          const timestamp = (/* @__PURE__ */ new Date()).toISOString();
+          const event = {
+            type: "update",
+            issueId,
+            timestamp,
+            data: {
+              blockedBy: [...issue.blockedBy, resolvedBlockerId]
+            }
+          };
+          appendEvent(event, pebbleDir);
+          const updatedIssue = getIssue(issueId);
+          res.json(updatedIssue);
+        } 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;
+          }
+          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 event = {
+            type: "update",
+            issueId,
+            timestamp,
+            data: {
+              blockedBy: issue.blockedBy.filter((id) => id !== resolvedBlockerId)
+            }
+          };
+          appendEvent(event, pebbleDir);
+          const updatedIssue = getIssue(issueId);
+          res.json(updatedIssue);
+        } catch (error) {
+          res.status(500).json({ error: error.message });
+        }
+      });
+      const __filename2 = fileURLToPath(import.meta.url);
+      const __dirname2 = path2.dirname(__filename2);
+      const uiPath = path2.resolve(__dirname2, "../ui");
+      app.use(express.static(uiPath));
+      app.get("*", (_req, res) => {
+        res.sendFile(path2.join(uiPath, "index.html"));
+      });
+      const requestedPort = parseInt(options.port, 10);
+      const actualPort = await findAvailablePort(requestedPort);
+      if (actualPort !== requestedPort) {
+        console.log(`Port ${requestedPort} is busy, using ${actualPort} instead`);
+      }
+      app.listen(actualPort, () => {
+        const url = `http://localhost:${actualPort}`;
+        console.log(`Pebble UI running at ${url}`);
+        if (options.open !== false) {
+          open(url);
+        }
+      });
+    } catch (error) {
+      outputError(error, pretty);
+      process.exit(1);
+    }
+  });
+}
+
+// src/cli/commands/import.ts
+import * as fs3 from "fs";
+import * as readline from "readline";
+import * as path3 from "path";
+function importCommand(program2) {
+  program2.command("import <file>").description("Import issues from a Beads issues.jsonl file").option("--dry-run", "Show what would be imported without writing").option("--prefix <prefix>", "Override the ID prefix (default: derive from folder name)").action(async (file, options) => {
+    const pretty = program2.opts().pretty ?? false;
+    try {
+      if (!fs3.existsSync(file)) {
+        throw new Error(`File not found: ${file}`);
+      }
+      const beadsIssues = await parseBeadsFile(file);
+      if (beadsIssues.length === 0) {
+        console.log(pretty ? "No issues found in file." : formatJson({ imported: 0 }));
+        return;
+      }
+      const prefix = options.prefix ?? derivePrefix(path3.basename(process.cwd()));
+      const { events, idMap, stats } = convertToPebbleEvents(beadsIssues, prefix);
+      if (options.dryRun) {
+        if (pretty) {
+          console.log("Dry run - would import:");
+          console.log(`  ${stats.created} issues`);
+          console.log(`  ${stats.closed} closed issues`);
+          console.log(`  ${stats.dependencies} block dependencies`);
+          console.log(`  ${stats.parentChild} parent-child relationships`);
+          console.log(`  ${stats.comments} comments`);
+          console.log("\nID mapping (beads -> pebble):");
+          for (const [beadsId, pebbleId] of idMap) {
+            console.log(`  ${beadsId} -> ${pebbleId}`);
+          }
+        } else {
+          console.log(formatJson({
+            dryRun: true,
+            stats,
+            idMap: Object.fromEntries(idMap)
+          }));
+        }
+        return;
+      }
+      const pebbleDir = ensurePebbleDir();
+      for (const event of events) {
+        appendEvent(event, pebbleDir);
+      }
+      if (pretty) {
+        console.log(`Imported ${stats.created} issues from ${file}`);
+        console.log(`  ${stats.closed} closed`);
+        console.log(`  ${stats.dependencies} block dependencies`);
+        console.log(`  ${stats.parentChild} parent-child relationships`);
+        console.log(`  ${stats.comments} comments`);
+      } else {
+        console.log(formatJson({
+          imported: stats.created,
+          closed: stats.closed,
+          dependencies: stats.dependencies,
+          parentChild: stats.parentChild,
+          comments: stats.comments,
+          idMap: Object.fromEntries(idMap)
+        }));
+      }
+    } catch (error) {
+      outputError(error, pretty);
+    }
+  });
+}
+async function parseBeadsFile(filePath) {
+  const issues = [];
+  const fileStream = fs3.createReadStream(filePath);
+  const rl = readline.createInterface({
+    input: fileStream,
+    crlfDelay: Infinity
+  });
+  for await (const line of rl) {
+    if (line.trim()) {
+      try {
+        const issue = JSON.parse(line);
+        issues.push(issue);
+      } catch {
+      }
+    }
+  }
+  return issues;
+}
+function convertToPebbleEvents(beadsIssues, prefix) {
+  const events = [];
+  const idMap = /* @__PURE__ */ new Map();
+  const issueTypeMap = /* @__PURE__ */ new Map();
+  const stats = { created: 0, closed: 0, dependencies: 0, comments: 0, parentChild: 0 };
+  for (const issue of beadsIssues) {
+    const suffix = generateSuffix();
+    const pebbleId = `${prefix}-${suffix}`;
+    idMap.set(issue.id, pebbleId);
+    issueTypeMap.set(issue.id, issue.issue_type);
+  }
+  for (const issue of beadsIssues) {
+    const pebbleId = idMap.get(issue.id);
+    let type = "task";
+    if (issue.issue_type === "bug") {
+      type = "bug";
+    } else if (issue.issue_type === "epic") {
+      type = "epic";
+    }
+    const priority = Math.max(0, Math.min(4, issue.priority));
+    let parent;
+    const blockedBy = [];
+    if (issue.dependencies) {
+      for (const dep of issue.dependencies) {
+        if (dep.type === "parent-child") {
+          const targetType = issueTypeMap.get(dep.depends_on_id);
+          if (targetType === "epic") {
+            const parentPebbleId = idMap.get(dep.depends_on_id);
+            if (parentPebbleId) {
+              parent = parentPebbleId;
+              stats.parentChild++;
+            }
+          }
+        } else if (dep.type === "blocks" && dep.depends_on_id !== issue.id) {
+          const blockerPebbleId = idMap.get(dep.depends_on_id);
+          if (blockerPebbleId) {
+            blockedBy.push(blockerPebbleId);
+            stats.dependencies++;
+          }
+        }
+      }
+    }
+    const createEvent = {
+      type: "create",
+      issueId: pebbleId,
+      timestamp: issue.created_at,
+      data: {
+        title: issue.title,
+        type,
+        priority,
+        description: issue.description,
+        parent
+      }
+    };
+    events.push(createEvent);
+    stats.created++;
+    if (blockedBy.length > 0) {
+      const updateEvent = {
+        type: "update",
+        issueId: pebbleId,
+        timestamp: issue.created_at,
+        data: {
+          blockedBy
+        }
+      };
+      events.push(updateEvent);
+    }
+    let status = "open";
+    if (issue.status === "in_progress") {
+      status = "in_progress";
+    } else if (issue.status === "blocked") {
+      status = "blocked";
+    } else if (issue.status === "closed") {
+      status = "closed";
+    }
+    if (status !== "open" && status !== "closed") {
+      const statusEvent = {
+        type: "update",
+        issueId: pebbleId,
+        timestamp: issue.updated_at,
+        data: {
+          status
+        }
+      };
+      events.push(statusEvent);
+    }
+    if (status === "closed") {
+      const closeEvent = {
+        type: "close",
+        issueId: pebbleId,
+        timestamp: issue.closed_at ?? issue.updated_at,
+        data: {
+          reason: issue.close_reason
+        }
+      };
+      events.push(closeEvent);
+      stats.closed++;
+    }
+  }
+  return { events, idMap, stats };
+}
+function generateSuffix() {
+  const chars = "abcdefghijklmnopqrstuvwxyz0123456789";
+  let result = "";
+  for (let i = 0; i < 6; i++) {
+    result += chars.charAt(Math.floor(Math.random() * chars.length));
+  }
+  return result;
+}
+
+// src/cli/commands/merge.ts
+import * as fs4 from "fs";
+import * as path4 from "path";
+function mergeEvents(filePaths) {
+  const allEvents = [];
+  for (const filePath of filePaths) {
+    const events = readEventsFromFile(filePath);
+    for (const event of events) {
+      allEvents.push({ ...event, _source: filePath });
+    }
+  }
+  allEvents.sort((a, b) => new Date(a.timestamp).getTime() - new Date(b.timestamp).getTime());
+  return allEvents.map(({ _source, ...event }) => event);
+}
+function mergeIssues(filePaths) {
+  const merged = /* @__PURE__ */ new Map();
+  for (const filePath of filePaths) {
+    const events = readEventsFromFile(filePath);
+    const state = computeState(events);
+    for (const [id, issue] of state) {
+      const existing = merged.get(id);
+      if (!existing) {
+        merged.set(id, { issue, sources: /* @__PURE__ */ new Set([filePath]) });
+      } else {
+        existing.sources.add(filePath);
+        if (new Date(issue.updatedAt) > new Date(existing.issue.updatedAt)) {
+          merged.set(id, { issue, sources: existing.sources });
+        }
+      }
+    }
+  }
+  return Array.from(merged.values()).map(({ issue, sources }) => ({
+    ...issue,
+    _sources: Array.from(sources)
+  }));
+}
+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) => {
+    const pretty = program2.opts().pretty ?? false;
+    const filePaths = [];
+    for (const file of files) {
+      const resolved = path4.resolve(process.cwd(), file);
+      if (!fs4.existsSync(resolved)) {
+        console.error(`Error: File not found: ${file}`);
+        process.exit(1);
+      }
+      filePaths.push(resolved);
+    }
+    if (filePaths.length < 2) {
+      console.error("Error: At least 2 files required for merge");
+      process.exit(1);
+    }
+    try {
+      let output;
+      if (options.events) {
+        const events = mergeEvents(filePaths);
+        output = events.map((e) => JSON.stringify(e)).join("\n") + "\n";
+      } else {
+        const issues = mergeIssues(filePaths);
+        const outputIssues = options.showSources ? issues : issues.map(({ _sources, ...issue }) => issue);
+        output = pretty ? JSON.stringify(outputIssues, null, 2) : JSON.stringify(outputIssues);
+      }
+      if (options.output) {
+        fs4.writeFileSync(options.output, output + "\n", "utf-8");
+        console.error(`Merged ${filePaths.length} files to ${options.output}`);
+      } else {
+        console.log(output);
+      }
+    } catch (error) {
+      console.error(`Error: ${error.message}`);
+      process.exit(1);
+    }
+  });
+}
+
+// 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)");
+createCommand(program);
+updateCommand(program);
+closeCommand(program);
+reopenCommand(program);
+claimCommand(program);
+listCommand(program);
+showCommand(program);
+readyCommand(program);
+blockedCommand(program);
+depCommand(program);
+commentsCommand(program);
+graphCommand(program);
+uiCommand(program);
+importCommand(program);
+mergeCommand(program);
+program.parse();
+//# sourceMappingURL=index.js.map