@dunnewold-labs/mr-manager 0.1.0

package/dist/index.js

@@ -0,0 +1,1167 @@
+#!/usr/bin/env node
+var __defProp = Object.defineProperty;
+var __getOwnPropSymbols = Object.getOwnPropertySymbols;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __propIsEnum = Object.prototype.propertyIsEnumerable;
+var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __spreadValues = (a, b) => {
+  for (var prop in b || (b = {}))
+    if (__hasOwnProp.call(b, prop))
+      __defNormalProp(a, prop, b[prop]);
+  if (__getOwnPropSymbols)
+    for (var prop of __getOwnPropSymbols(b)) {
+      if (__propIsEnum.call(b, prop))
+        __defNormalProp(a, prop, b[prop]);
+    }
+  return a;
+};
+var __async = (__this, __arguments, generator) => {
+  return new Promise((resolve3, reject) => {
+    var fulfilled = (value) => {
+      try {
+        step(generator.next(value));
+      } catch (e) {
+        reject(e);
+      }
+    };
+    var rejected = (value) => {
+      try {
+        step(generator.throw(value));
+      } catch (e) {
+        reject(e);
+      }
+    };
+    var step = (x) => x.done ? resolve3(x.value) : Promise.resolve(x.value).then(fulfilled, rejected);
+    step((generator = generator.apply(__this, __arguments)).next());
+  });
+};
+
+// index.ts
+import { Command as Command15 } from "commander";
+
+// commands/init.ts
+import { Command } from "commander";
+
+// config.ts
+import { readFileSync, writeFileSync, mkdirSync, existsSync } from "fs";
+import { homedir } from "os";
+import { join } from "path";
+var CONFIG_DIR = join(homedir(), ".mr-manager");
+var CONFIG_FILE = join(CONFIG_DIR, "config.json");
+var DEFAULT_CONFIG = {
+  apiUrl: "https://mr-manager-gold.vercel.app",
+  apiKey: "",
+  directories: {}
+};
+function loadConfig() {
+  if (!existsSync(CONFIG_FILE)) {
+    return __spreadValues({}, DEFAULT_CONFIG);
+  }
+  const raw = readFileSync(CONFIG_FILE, "utf-8");
+  return __spreadValues(__spreadValues({}, DEFAULT_CONFIG), JSON.parse(raw));
+}
+function saveConfig(config) {
+  if (!existsSync(CONFIG_DIR)) {
+    mkdirSync(CONFIG_DIR, { recursive: true });
+  }
+  writeFileSync(CONFIG_FILE, JSON.stringify(config, null, 2) + "\n");
+}
+function getLinkedProjectId() {
+  var _a;
+  const config = loadConfig();
+  const cwd = process.cwd();
+  return (_a = config.directories[cwd]) != null ? _a : null;
+}
+
+// commands/init.ts
+var initCommand = new Command("init").description("Set up Mr. Manager CLI authentication").option("--url <url>", "API URL", "https://mr-manager-gold.vercel.app").action((opts) => __async(null, null, function* () {
+  const config = loadConfig();
+  config.apiUrl = opts.url;
+  const url = `${config.apiUrl}/api/auth/key`;
+  const res = yield fetch(url, {
+    method: "POST",
+    headers: { "Content-Type": "application/json" },
+    body: JSON.stringify({ name: "cli" })
+  });
+  if (!res.ok) {
+    const text = yield res.text();
+    console.error(`Failed to create API key: ${res.status} ${text}`);
+    process.exit(1);
+  }
+  const data = yield res.json();
+  config.apiKey = data.key;
+  saveConfig(config);
+  console.log("Authenticated successfully. Config saved to ~/.mr-manager/config.json");
+}));
+
+// commands/auth.ts
+import { Command as Command2 } from "commander";
+var authCommand = new Command2("auth").description("Manually set an API key").argument("<key>", "API key to save").option("--url <url>", "API URL", "https://mr-manager-gold.vercel.app").action((key, opts) => __async(null, null, function* () {
+  const config = loadConfig();
+  config.apiKey = key;
+  if (opts.url) config.apiUrl = opts.url;
+  saveConfig(config);
+  console.log("API key saved to ~/.mr-manager/config.json");
+}));
+
+// commands/login.ts
+import { Command as Command3 } from "commander";
+import { createServer } from "http";
+import { spawn } from "child_process";
+function getRandomPort() {
+  return Math.floor(Math.random() * (65535 - 49152 + 1)) + 49152;
+}
+function openBrowser(url) {
+  const cmd = process.platform === "darwin" ? "open" : process.platform === "win32" ? "start" : "xdg-open";
+  spawn(cmd, [url], { detached: true, stdio: "ignore" }).unref();
+}
+var loginCommand = new Command3("login").description("Authenticate the CLI via browser (Google OAuth)").option("--url <url>", "API URL", "https://mr-manager-gold.vercel.app").action((opts) => __async(null, null, function* () {
+  var _a, _b;
+  const config = loadConfig();
+  const apiUrl = (_b = (_a = opts.url) != null ? _a : config.apiUrl) != null ? _b : "https://mr-manager-gold.vercel.app";
+  const port = getRandomPort();
+  const key = yield new Promise((resolve3, reject) => {
+    const server = createServer((req, res) => {
+      var _a2;
+      const url = new URL((_a2 = req.url) != null ? _a2 : "/", `http://localhost:${port}`);
+      const key2 = url.searchParams.get("key");
+      res.writeHead(200, { "Content-Type": "text/html" });
+      res.end(`
+          <html><body style="font-family:sans-serif;text-align:center;padding:60px">
+            <h2>${key2 ? "\u2713 Authenticated!" : "Something went wrong."}</h2>
+            <p>${key2 ? "You can close this tab and return to the terminal." : "No key received. Please try again."}</p>
+          </body></html>
+        `);
+      server.close();
+      if (key2) resolve3(key2);
+      else reject(new Error("No key received from server"));
+    });
+    server.listen(port, () => {
+      const loginUrl = `${apiUrl}/login?cliPort=${port}`;
+      console.log(`
+Opening browser for authentication\u2026`);
+      console.log(`If the browser doesn't open, visit:
+  ${loginUrl}
+`);
+      openBrowser(loginUrl);
+    });
+    server.on("error", reject);
+    setTimeout(() => {
+      server.close();
+      reject(new Error("Login timed out after 5 minutes"));
+    }, 5 * 60 * 1e3);
+  });
+  config.apiKey = key;
+  config.apiUrl = apiUrl;
+  saveConfig(config);
+  console.log("Authenticated successfully. Config saved to ~/.mr-manager/config.json");
+}));
+
+// commands/projects.ts
+import { Command as Command4 } from "commander";
+
+// api.ts
+var ApiError = class extends Error {
+  constructor(status, statusText, body) {
+    super(`API error ${status} ${statusText}: ${body}`);
+    this.status = status;
+    this.statusText = statusText;
+    this.body = body;
+    this.name = "ApiError";
+  }
+};
+function request(method, path, body) {
+  return __async(this, null, function* () {
+    const config = loadConfig();
+    if (!config.apiKey) {
+      throw new Error(
+        'Not authenticated. Run "mr init" to set up your API key.'
+      );
+    }
+    const url = `${config.apiUrl}${path}`;
+    const headers = {
+      Authorization: `Bearer ${config.apiKey}`,
+      "Content-Type": "application/json"
+    };
+    const res = yield fetch(url, {
+      method,
+      headers,
+      body: body ? JSON.stringify(body) : void 0
+    });
+    const text = yield res.text();
+    if (!res.ok) {
+      throw new ApiError(res.status, res.statusText, text);
+    }
+    if (!text) return null;
+    try {
+      return JSON.parse(text);
+    } catch (e) {
+      return text;
+    }
+  });
+}
+var api = {
+  get: (path) => request("GET", path),
+  post: (path, body) => request("POST", path, body),
+  patch: (path, body) => request("PATCH", path, body),
+  del: (path) => request("DELETE", path)
+};
+
+// commands/projects.ts
+var projectsCommand = new Command4("projects").description("List all projects").action(() => __async(null, null, function* () {
+  const projects = yield api.get("/api/projects");
+  console.log(JSON.stringify(projects, null, 2));
+}));
+
+// commands/tasks.ts
+import { Command as Command5 } from "commander";
+var tasksCommand = new Command5("tasks").description("List tasks for the linked project").option("--in-progress", "Show only in-progress tasks").option("--completed", "Show only completed tasks").option("--all", "Show all tasks").action((opts) => __async(null, null, function* () {
+  const projectId = getLinkedProjectId();
+  if (!projectId) {
+    console.error(
+      'No project linked to this directory. Run "mr link <project-id>" first.'
+    );
+    process.exit(1);
+  }
+  let path = `/api/tasks`;
+  const params = new URLSearchParams();
+  params.set("projectId", projectId);
+  if (opts.inProgress) {
+    params.set("inProgress", "true");
+  } else if (opts.completed) {
+    params.set("completed", "true");
+  } else if (!opts.all) {
+    params.set("completed", "false");
+  }
+  path += `?${params.toString()}`;
+  const tasks = yield api.get(path);
+  console.log(JSON.stringify(tasks, null, 2));
+}));
+
+// commands/link.ts
+import { Command as Command6 } from "commander";
+var linkCommand = new Command6("link").description("Associate current directory with a project").argument("[project-id]", "Project ID to link").action((projectId) => __async(null, null, function* () {
+  if (!projectId) {
+    const current = getLinkedProjectId();
+    if (current) {
+      console.log(`Linked to project: ${current}`);
+    } else {
+      console.log("No project linked to this directory.");
+    }
+    return;
+  }
+  const config = loadConfig();
+  config.directories[process.cwd()] = projectId;
+  saveConfig(config);
+  console.log(`Linked ${process.cwd()} to project ${projectId}`);
+}));
+var unlinkCommand = new Command6("unlink").description("Remove current directory's project association").action(() => __async(null, null, function* () {
+  const config = loadConfig();
+  const cwd = process.cwd();
+  if (!config.directories[cwd]) {
+    console.log("No project linked to this directory.");
+    return;
+  }
+  delete config.directories[cwd];
+  saveConfig(config);
+  console.log("Unlinked current directory.");
+}));
+
+// commands/context.ts
+import { Command as Command7 } from "commander";
+import { writeFileSync as writeFileSync2, mkdirSync as mkdirSync2, existsSync as existsSync2 } from "fs";
+import { join as join2 } from "path";
+var contextCommand = new Command7("context").description("Output project context JSON for Claude Code").option("--install", "Install Claude Code command to .claude/commands/").action((opts) => __async(null, null, function* () {
+  var _a;
+  if (opts.install) {
+    const dir = join2(process.cwd(), ".claude", "commands");
+    if (!existsSync2(dir)) {
+      mkdirSync2(dir, { recursive: true });
+    }
+    const filePath = join2(dir, "mr-tasks.md");
+    writeFileSync2(
+      filePath,
+      "Run the following command and use the output as context for this project:\n\n`mr context`\n"
+    );
+    console.log(`Installed Claude Code command to ${filePath}`);
+    return;
+  }
+  const projectId = getLinkedProjectId();
+  if (!projectId) {
+    console.error(
+      'No project linked to this directory. Run "mr link <project-id>" first.'
+    );
+    process.exit(1);
+  }
+  const project = yield api.get(`/api/projects/${projectId}`);
+  const allTasks = yield api.get(
+    `/api/projects/${projectId}/tasks`
+  );
+  const inProgress = allTasks.filter((t) => t.inProgress && !t.completed);
+  const todo = allTasks.filter((t) => !t.completed && !t.inProgress);
+  const recentlyCompleted = allTasks.filter((t) => t.completed);
+  const summaryLines = [
+    `Project: ${project.name} (${project.status})`,
+    ...inProgress.map((t) => `In Progress: ${t.title}`),
+    `Todo: ${todo.length} tasks`,
+    `Recently Completed: ${recentlyCompleted.length} tasks`
+  ];
+  const output = {
+    project: {
+      name: project.name,
+      status: project.status,
+      description: (_a = project.description) != null ? _a : ""
+    },
+    tasks: {
+      inProgress,
+      todo,
+      recentlyCompleted
+    },
+    summary: summaryLines.join("\n")
+  };
+  console.log(JSON.stringify(output, null, 2));
+}));
+
+// commands/watch.ts
+import { Command as Command8 } from "commander";
+import { spawn as spawn2, exec } from "child_process";
+import { resolve } from "path";
+import * as readline from "readline";
+var c = {
+  reset: "\x1B[0m",
+  bold: "\x1B[1m",
+  dim: "\x1B[2m",
+  cyan: "\x1B[36m",
+  green: "\x1B[32m",
+  yellow: "\x1B[33m",
+  red: "\x1B[31m",
+  magenta: "\x1B[35m",
+  blue: "\x1B[34m",
+  white: "\x1B[37m",
+  gray: "\x1B[90m"
+};
+function paint(color, text) {
+  return `${c[color]}${text}${c.reset}`;
+}
+function timestamp() {
+  return paint("gray", (/* @__PURE__ */ new Date()).toLocaleTimeString("en-US", { hour12: false }));
+}
+function taskTag(sid) {
+  return paint("yellow", `[${sid}]`);
+}
+function watchTag() {
+  return paint("magenta", "[watch]");
+}
+function logInfo(prefix, msg) {
+  console.log(`${timestamp()} ${prefix} ${msg}`);
+}
+function logSuccess(prefix, msg) {
+  console.log(`${timestamp()} ${prefix} ${paint("green", "\u2713")} ${msg}`);
+}
+function logError(prefix, msg) {
+  console.error(`${timestamp()} ${prefix} ${paint("red", "\u2717")} ${msg}`);
+}
+function logWarn(prefix, msg) {
+  console.log(`${timestamp()} ${prefix} ${paint("yellow", "!")} ${msg}`);
+}
+function logDispatch(prefix, msg) {
+  console.log(`${timestamp()} ${prefix} ${paint("cyan", "\u2192")} ${msg}`);
+}
+function logSpinner(prefix, msg) {
+  console.log(`${timestamp()} ${prefix} ${paint("blue", "\u27F3")} ${msg}`);
+}
+function findDirectoryForProject(config, projectId, rootDir) {
+  for (const [dir, pid] of Object.entries(config.directories)) {
+    if (pid === projectId && resolve(dir).startsWith(resolve(rootDir))) {
+      return dir;
+    }
+  }
+  return null;
+}
+function slugify(title) {
+  return title.toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-+|-+$/g, "").slice(0, 30);
+}
+function shortId(id) {
+  return id.slice(0, 8);
+}
+function worktreePath(sid) {
+  return `.mr-worktrees/mr-${sid}`;
+}
+function pullLatestMain(repoDir, prefix) {
+  return new Promise((resolve3) => {
+    exec(
+      "git pull origin main --ff-only",
+      { cwd: repoDir },
+      (err, stdout, stderr) => {
+        if (err) {
+          logWarn(prefix, `git pull failed (proceeding anyway): ${stderr.trim() || err.message}`);
+        } else {
+          const msg = stdout.trim();
+          if (msg && msg !== "Already up to date.") {
+            logInfo(prefix, `pulled latest main: ${paint("gray", msg.split("\n")[0])}`);
+          }
+        }
+        resolve3();
+      }
+    );
+  });
+}
+function buildPlanningPrompt(task, repoDir) {
+  const notes = task.notes ? `
+
+Task notes:
+${task.notes}` : "";
+  return [
+    `You are reviewing a task from MR Manager. Your job is to produce a concise implementation plan \u2014 do NOT make any changes yet.`,
+    ``,
+    `Working directory: ${repoDir}`,
+    ``,
+    `## Task`,
+    `Title: ${task.title}`,
+    `ID: ${task.id}${notes}`,
+    ``,
+    `## Instructions`,
+    `1. Run \`mr context\` to understand the project state.`,
+    `2. Explore the relevant files and repos under ${repoDir}.`,
+    `3. Output a short plan: which files/repos you would change, what the approach is, and any risks or open questions.`,
+    ``,
+    `Do not write or edit any files. Output the plan only.`
+  ].join("\n");
+}
+function findPrUrl(branchName, repoDir) {
+  return new Promise((resolve3) => {
+    exec(
+      `gh pr view "${branchName}" --json url -q .url`,
+      { cwd: repoDir },
+      (err, stdout) => {
+        if (err) resolve3(null);
+        else resolve3(stdout.trim() || null);
+      }
+    );
+  });
+}
+function buildExecutionPrompt(task, repoDir, subtasks) {
+  const sid = shortId(task.id);
+  const slug = slugify(task.title);
+  const branchName = `mr/${sid}/${slug}`;
+  const wtPath = worktreePath(sid);
+  const notes = task.notes ? `
+
+Task notes:
+${task.notes}` : "";
+  const pendingSubtasks = subtasks.filter((s) => !s.completed);
+  const subtaskSection = pendingSubtasks.length > 0 ? [
+    ``,
+    `## Subtasks`,
+    ``,
+    `The following subtasks need to be completed. As you finish each one, mark it done by running:`,
+    `\`mr subtask-complete ${task.id} <subtask-id>\``,
+    ``,
+    ...pendingSubtasks.map((s) => `- [ ] ${s.title}  (id: ${s.id})`),
+    ``
+  ].join("\n") : "";
+  return [
+    `You are an autonomous agent working on a task from MR Manager.`,
+    `Working directory: ${repoDir}`,
+    ``,
+    `## Task`,
+    `Title: ${task.title}`,
+    `ID: ${task.id}${notes}`,
+    subtaskSection,
+    `## Instructions`,
+    ``,
+    `1. Run \`mr context\` first to understand the full project state.`,
+    ``,
+    `2. Set up an isolated working environment:`,
+    `   - If ${repoDir} is a git repo, create a worktree: \`git worktree add -b ${branchName} ${wtPath}\``,
+    `   - If ${repoDir} is not itself a git repo, it is likely a parent/wrapper folder \u2014 look for git repos inside it and create worktrees in the appropriate one(s).`,
+    `   - If the task spans multiple repos, set up worktrees in each one as needed.`,
+    ``,
+    `3. Implement the task. You may read, write, and run code across any relevant repos under ${repoDir}.`,
+    ...pendingSubtasks.length > 0 ? [
+      `   - Work through each subtask in order. After completing each subtask, immediately run \`mr subtask-complete ${task.id} <subtask-id>\` to mark it done before moving on.`
+    ] : [],
+    ``,
+    `4. Once implementation is complete, for each repo that has changes:`,
+    `   a. Commit all changes with a clear, descriptive message.`,
+    `   b. Push the branch: \`git push -u origin HEAD\``,
+    `   c. Open a pull request: \`gh pr create --title "${task.title}" --body "Resolves MR Manager task ${task.id}"\``,
+    ``,
+    `5. Clean up any worktrees you created: \`git worktree remove --force <path>\``,
+    ``,
+    `Complete all steps autonomously without asking for confirmation. Exit with code 0 when done.`
+  ].join("\n");
+}
+function runPlanningPhase(task, repoDir) {
+  return new Promise((resolve3, reject) => {
+    var _a, _b;
+    const child = spawn2(
+      "claude",
+      ["--permission-mode", "plan", "-p", buildPlanningPrompt(task, repoDir)],
+      { cwd: repoDir, stdio: ["ignore", "pipe", "pipe"] }
+    );
+    let output = "";
+    (_a = child.stdout) == null ? void 0 : _a.on("data", (d) => {
+      output += d.toString();
+    });
+    (_b = child.stderr) == null ? void 0 : _b.on("data", (d) => {
+      output += d.toString();
+    });
+    child.on("exit", (code) => {
+      if (code === 0) resolve3(output.trim());
+      else reject(new Error(`Planning exited with code ${code}
+${output.trim()}`));
+    });
+  });
+}
+function askYesNo(question) {
+  return new Promise((resolve3) => {
+    const rl = readline.createInterface({
+      input: process.stdin,
+      output: process.stdout
+    });
+    rl.question(question, (answer) => {
+      rl.close();
+      resolve3(answer.trim().toLowerCase() === "y" || answer.trim().toLowerCase() === "yes");
+    });
+  });
+}
+function spawnClaude(repoDir, prompt, prefix) {
+  var _a, _b;
+  const child = spawn2(
+    "claude",
+    ["-p", "--dangerously-skip-permissions", prompt],
+    { cwd: repoDir, stdio: ["ignore", "pipe", "pipe"] }
+  );
+  (_a = child.stdout) == null ? void 0 : _a.on("data", (data) => {
+    for (const line of data.toString().split("\n")) {
+      if (line) console.log(`${timestamp()} ${prefix} ${paint("dim", line)}`);
+    }
+  });
+  (_b = child.stderr) == null ? void 0 : _b.on("data", (data) => {
+    for (const line of data.toString().split("\n")) {
+      if (line) logError(prefix, paint("dim", line));
+    }
+  });
+  return child;
+}
+var watchCommand = new Command8("watch").description(
+  "Watch for in-progress tasks and autonomously dispatch Claude Code to work on them"
+).option("--interval <seconds>", "Polling interval in seconds", "15").option("--dry-run", "Show what would be dispatched without spawning Claude", false).option("--plan-approval", "Show Claude's plan and ask for approval before executing", false).option("--root <dir>", "Root directory filter for linked repos (default: cwd)").action((opts) => __async(null, null, function* () {
+  const intervalMs = parseInt(opts.interval, 10) * 1e3;
+  const dryRun = opts.dryRun;
+  const planApproval = opts.planApproval;
+  const rootDir = opts.root ? resolve(opts.root) : process.cwd();
+  const active = /* @__PURE__ */ new Map();
+  const failed = /* @__PURE__ */ new Map();
+  const queued = /* @__PURE__ */ new Set();
+  const approvalQueue = [];
+  let approvalRunning = false;
+  const flags = [
+    `interval=${paint("cyan", opts.interval + "s")}`,
+    `root=${paint("cyan", rootDir)}`,
+    ...planApproval ? [paint("yellow", "plan-approval")] : [],
+    ...dryRun ? [paint("yellow", "dry-run")] : []
+  ].join("  ");
+  const banner = [
+    ``,
+    paint("magenta", `  \u2554\u2566\u2557\u2566\u2550\u2557  \u2566 \u2566\u2554\u2550\u2557\u2554\u2566\u2557\u2554\u2550\u2557\u2566 \u2566`),
+    paint("magenta", `  \u2551\u2551\u2551\u2560\u2566\u255D  \u2551\u2551\u2551\u2560\u2550\u2563 \u2551 \u2551  \u2560\u2550\u2563`),
+    paint("magenta", `  \u2569 \u2569\u2569\u255A\u2550  \u255A\u2569\u255D\u2569 \u2569 \u2569 \u255A\u2550\u255D\u2569 \u2569`),
+    paint("dim", `  \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500`),
+    paint("dim", `  autonomous task runner \xB7 powered by claude`),
+    ``
+  ].join("\n");
+  console.log(banner);
+  console.log(`  ${flags}
+`);
+  function dispatchTask(task, repoDir) {
+    return __async(this, null, function* () {
+      const sid = shortId(task.id);
+      const slug = slugify(task.title);
+      const branchName = `mr/${sid}/${slug}`;
+      const prefix = taskTag(sid);
+      logDispatch(prefix, `"${paint("bold", task.title)}"  ${paint("gray", repoDir)}`);
+      yield pullLatestMain(repoDir, prefix);
+      let subtasks = [];
+      try {
+        subtasks = yield api.get(`/api/tasks/${task.id}/subtasks`);
+        const pending = subtasks.filter((s) => !s.completed);
+        if (pending.length > 0) {
+          logInfo(prefix, `${paint("cyan", String(pending.length))} subtask(s) to complete`);
+        }
+      } catch (e) {
+      }
+      const prompt = buildExecutionPrompt(task, repoDir, subtasks);
+      const child = spawnClaude(repoDir, prompt, prefix);
+      active.set(task.id, { process: child, title: task.title, repoDir });
+      child.on("exit", (code) => __async(null, null, function* () {
+        active.delete(task.id);
+        queued.delete(task.id);
+        if (code === 0) {
+          try {
+            const prUrl = yield findPrUrl(branchName, repoDir);
+            if (prUrl) {
+              logSuccess(prefix, `PR ready: ${paint("cyan", prUrl)}`);
+            } else {
+              logWarn(prefix, `No PR found for branch ${paint("cyan", branchName)}`);
+            }
+            yield api.patch(`/api/tasks/${task.id}`, __spreadValues({
+              inProgress: false,
+              readyForReview: true
+            }, prUrl ? { link: prUrl } : {}));
+            logSuccess(prefix, `"${paint("bold", task.title)}" marked ready for review`);
+          } catch (err) {
+            logError(prefix, `Failed to update task: ${err.message}`);
+          }
+        } else {
+          logError(prefix, `"${paint("bold", task.title)}" failed (exit ${code}), leaving status unchanged`);
+        }
+      }));
+    });
+  }
+  function processApprovalQueue() {
+    return __async(this, null, function* () {
+      if (approvalRunning || approvalQueue.length === 0) return;
+      approvalRunning = true;
+      const { task, repoDir } = approvalQueue.shift();
+      const sid = shortId(task.id);
+      const prefix = taskTag(sid);
+      try {
+        logSpinner(prefix, `Generating plan for "${paint("bold", task.title)}"\u2026`);
+        const plan = yield runPlanningPhase(task, repoDir);
+        const width = 64;
+        const divider = paint("gray", "\u2500".repeat(width));
+        const header = `${paint("bold", "Plan")}  "${paint("bold", task.title)}"  ${taskTag(sid)}`;
+        console.log(`
+${divider}`);
+        console.log(header);
+        console.log(divider);
+        console.log(plan);
+        console.log(`${divider}
+`);
+        const approved = yield askYesNo(
+          `${paint("cyan", "?")} Approve task "${paint("bold", task.title)}"? [y/N] `
+        );
+        if (approved) {
+          dispatchTask(task, repoDir);
+        } else {
+          logWarn(prefix, `"${paint("bold", task.title)}" denied \u2014 will not retry`);
+          failed.set(task.id, "denied by user");
+          queued.delete(task.id);
+        }
+      } catch (err) {
+        logError(prefix, `Planning failed: ${err.message} \u2014 will not retry`);
+        failed.set(task.id, `planning failed: ${err.message}`);
+        queued.delete(task.id);
+      } finally {
+        approvalRunning = false;
+        processApprovalQueue();
+      }
+    });
+  }
+  function poll() {
+    return __async(this, null, function* () {
+      let tasks;
+      try {
+        tasks = yield api.get("/api/tasks?inProgress=true&delegated=true");
+      } catch (err) {
+        logError(watchTag(), `Failed to fetch tasks: ${err.message}`);
+        return;
+      }
+      const config = loadConfig();
+      const inProgressIds = new Set(tasks.map((t) => t.id));
+      for (const [taskId, entry] of active) {
+        if (!inProgressIds.has(taskId)) {
+          logWarn(watchTag(), `Task ${paint("yellow", taskId.slice(0, 8))} no longer in-progress, terminating\u2026`);
+          entry.process.kill("SIGTERM");
+          active.delete(taskId);
+          queued.delete(taskId);
+        }
+      }
+      for (const taskId of failed.keys()) {
+        if (!inProgressIds.has(taskId)) failed.delete(taskId);
+      }
+      for (const taskId of queued) {
+        if (!inProgressIds.has(taskId)) queued.delete(taskId);
+      }
+      for (const task of tasks) {
+        if (queued.has(task.id)) continue;
+        if (failed.has(task.id)) continue;
+        const sid = shortId(task.id);
+        const prefix = taskTag(sid);
+        const repoDir = findDirectoryForProject(config, task.projectId, rootDir);
+        if (!repoDir) {
+          const reason = `no linked directory found under ${rootDir}`;
+          logError(prefix, `"${task.title}": ${reason} \u2014 will not retry`);
+          failed.set(task.id, reason);
+          continue;
+        }
+        queued.add(task.id);
+        if (dryRun) {
+          logInfo(
+            watchTag(),
+            `${paint("yellow", "[dry-run]")} would dispatch "${paint("bold", task.title)}" (${paint("gray", task.id)}) in ${paint("cyan", repoDir)}`
+          );
+          continue;
+        }
+        if (planApproval) {
+          approvalQueue.push({ task, repoDir });
+          processApprovalQueue();
+        } else {
+          dispatchTask(task, repoDir);
+        }
+      }
+    });
+  }
+  function shutdown() {
+    return __async(this, null, function* () {
+      console.log(`
+${timestamp()} ${watchTag()} Shutting down\u2026`);
+      for (const [taskId, entry] of active) {
+        logWarn(watchTag(), `Terminating Claude for task ${paint("yellow", taskId.slice(0, 8))}`);
+        entry.process.kill("SIGTERM");
+      }
+      active.clear();
+      process.exit(0);
+    });
+  }
+  process.on("SIGINT", shutdown);
+  process.on("SIGTERM", shutdown);
+  yield poll();
+  setInterval(poll, intervalMs);
+}));
+
+// commands/start.ts
+import { Command as Command9 } from "commander";
+var c2 = {
+  reset: "\x1B[0m",
+  bold: "\x1B[1m",
+  dim: "\x1B[2m",
+  cyan: "\x1B[36m",
+  green: "\x1B[32m",
+  yellow: "\x1B[33m",
+  magenta: "\x1B[35m",
+  gray: "\x1B[90m"
+};
+function paint2(color, text) {
+  return `${c2[color]}${text}${c2.reset}`;
+}
+function printTaskBanner(action, title, id) {
+  const sid = id.slice(0, 8);
+  const divider = paint2("dim", "\u2500".repeat(44));
+  console.log([
+    ``,
+    paint2("magenta", `  \u2554\u2566\u2557\u2566\u2550\u2557  `) + paint2("bold", action),
+    paint2("magenta", `  \u2551\u2551\u2551\u2560\u2566\u255D  `) + divider,
+    paint2("magenta", `  \u2569 \u2569\u2569\u255A\u2550  `) + title,
+    `           ` + paint2("gray", sid),
+    ``
+  ].join("\n"));
+}
+var startCommand = new Command9("start").description("Mark a task as in-progress (you are working on it)").argument("<task-id>", "Task ID to start").action((taskId) => __async(null, null, function* () {
+  const task = yield api.patch(`/api/tasks/${taskId}`, {
+    inProgress: true,
+    delegated: false
+  });
+  printTaskBanner(paint2("green", "start"), task.title, task.id);
+}));
+var delegateCommand = new Command9("delegate").description("Mark a task as in-progress and delegate it to the watch agent").argument("<task-id>", "Task ID to delegate").action((taskId) => __async(null, null, function* () {
+  const task = yield api.patch(`/api/tasks/${taskId}`, {
+    inProgress: true,
+    delegated: true
+  });
+  printTaskBanner(paint2("cyan", "delegate"), task.title, task.id);
+}));
+
+// commands/create.ts
+import { Command as Command10 } from "commander";
+var createCommand = new Command10("create").description("Create a new task in the linked project").argument("<title>", "Task title").option("--notes <notes>", "Task notes").option("--in-progress", "Mark the task as in-progress immediately").action((title, opts) => __async(null, null, function* () {
+  var _a;
+  const projectId = getLinkedProjectId();
+  if (!projectId) {
+    console.error(
+      'No project linked to this directory. Run "mr link <project-id>" first.'
+    );
+    process.exit(1);
+  }
+  const task = yield api.post("/api/tasks", {
+    title,
+    projectId,
+    notes: opts.notes,
+    inProgress: (_a = opts.inProgress) != null ? _a : false
+  });
+  const t = task;
+  console.log(`Created: ${t.title} (${t.id})`);
+}));
+
+// commands/complete.ts
+import { Command as Command11 } from "commander";
+var c3 = {
+  reset: "\x1B[0m",
+  bold: "\x1B[1m",
+  dim: "\x1B[2m",
+  cyan: "\x1B[36m",
+  green: "\x1B[32m",
+  yellow: "\x1B[33m",
+  magenta: "\x1B[35m",
+  gray: "\x1B[90m"
+};
+function paint3(color, text) {
+  return `${c3[color]}${text}${c3.reset}`;
+}
+function printTaskBanner2(action, title, id) {
+  const sid = id.slice(0, 8);
+  const divider = paint3("dim", "\u2500".repeat(44));
+  console.log([
+    ``,
+    paint3("magenta", `  \u2554\u2566\u2557\u2566\u2550\u2557  `) + paint3("bold", action),
+    paint3("magenta", `  \u2551\u2551\u2551\u2560\u2566\u255D  `) + divider,
+    paint3("magenta", `  \u2569 \u2569\u2569\u255A\u2550  `) + title,
+    `           ` + paint3("gray", sid),
+    ``
+  ].join("\n"));
+}
+var completeCommand = new Command11("complete").description("Mark a task as completed").argument("<task-id>", "Task ID to complete").action((taskId) => __async(null, null, function* () {
+  const task = yield api.patch(`/api/tasks/${taskId}`, {
+    completed: true,
+    inProgress: false
+  });
+  printTaskBanner2(paint3("green", "complete \u2713"), task.title, task.id);
+}));
+
+// commands/subtask-complete.ts
+import { Command as Command12 } from "commander";
+var subtaskCompleteCommand = new Command12("subtask-complete").description("Mark a subtask as completed").argument("<task-id>", "Parent task ID").argument("<subtask-id>", "Subtask ID to complete").action((taskId, subtaskId) => __async(null, null, function* () {
+  const subtask = yield api.patch(
+    `/api/tasks/${taskId}/subtasks/${subtaskId}`,
+    { completed: true }
+  );
+  console.log(`\u2713 Subtask completed: ${subtask.title}`);
+}));
+
+// commands/digest.ts
+import { Command as Command13 } from "commander";
+import { spawn as spawn3 } from "child_process";
+var c4 = {
+  reset: "\x1B[0m",
+  bold: "\x1B[1m",
+  dim: "\x1B[2m",
+  cyan: "\x1B[36m",
+  green: "\x1B[32m",
+  yellow: "\x1B[33m",
+  red: "\x1B[31m",
+  magenta: "\x1B[35m",
+  gray: "\x1B[90m"
+};
+function paint4(color, text) {
+  return `${c4[color]}${text}${c4.reset}`;
+}
+function timestamp2() {
+  return paint4("gray", (/* @__PURE__ */ new Date()).toLocaleTimeString("en-US", { hour12: false }));
+}
+function digestTag() {
+  return paint4("magenta", "[digest]");
+}
+function shortId2(id) {
+  return id.slice(0, 8);
+}
+function log(msg) {
+  console.log(`${timestamp2()} ${digestTag()} ${msg}`);
+}
+function logOk(msg) {
+  console.log(`${timestamp2()} ${digestTag()} ${paint4("green", "\u2713")} ${msg}`);
+}
+function logErr(msg) {
+  console.error(`${timestamp2()} ${digestTag()} ${paint4("red", "\u2717")} ${msg}`);
+}
+function buildPrompt(messages) {
+  const emailsText = messages.map(
+    (msg, i) => `Email ${i + 1}:
+ID: ${msg.id}
+Subject: ${msg.subject}
+From: ${msg.sender} <${msg.senderEmail}>
+Date: ${msg.date}
+Snippet: ${msg.snippet}
+Body preview: ${msg.body.slice(0, 500)}`
+  ).join("\n\n---\n\n");
+  return `You are an email triage assistant. Analyze the following unread emails and produce a structured digest.
+
+For each email, determine:
+1. Is it relevant/actionable (requires attention, is personal, work-related, or important)?
+2. Or is it not relevant (newsletters, marketing, automated notifications, promotions)?
+
+Also write a 2-3 sentence executive summary of the overall inbox state.
+
+Here are the unread emails:
+
+${emailsText}
+
+Respond with a JSON object in this exact format:
+{
+  "summary": "2-3 sentence overview of the inbox",
+  "items": [
+    {
+      "emailId": "the email ID",
+      "isRelevant": true or false,
+      "relevanceReason": "brief explanation of why relevant or not"
+    }
+  ]
+}
+
+Be conservative with "isRelevant: false" \u2014 only mark as not relevant if clearly promotional, newsletter, or automated. Personal emails, work emails, and anything requiring a response should be relevant.`;
+}
+function runClaude(prompt) {
+  return new Promise((resolve3, reject) => {
+    var _a, _b;
+    const child = spawn3("claude", ["-p", "--dangerously-skip-permissions", prompt], {
+      stdio: ["ignore", "pipe", "pipe"]
+    });
+    let output = "";
+    let errOutput = "";
+    (_a = child.stdout) == null ? void 0 : _a.on("data", (d) => {
+      output += d.toString();
+    });
+    (_b = child.stderr) == null ? void 0 : _b.on("data", (d) => {
+      errOutput += d.toString();
+    });
+    child.on("exit", (code) => {
+      if (code === 0) resolve3(output.trim());
+      else reject(new Error(`claude exited with code ${code}
+${errOutput.trim()}`));
+    });
+  });
+}
+function processDigest(digest) {
+  return __async(this, null, function* () {
+    const sid = shortId2(digest.id);
+    if (digest.rawMessages.length === 0) {
+      yield api.post(`/api/email-digest/${digest.id}/complete`, {
+        summary: "No unread emails found in your inbox.",
+        items: []
+      });
+      logOk(`${paint4("yellow", sid)} completed (no emails)`);
+      return;
+    }
+    log(`${paint4("yellow", sid)} analyzing ${paint4("cyan", String(digest.rawMessages.length))} emails\u2026`);
+    const prompt = buildPrompt(digest.rawMessages);
+    const output = yield runClaude(prompt);
+    const jsonMatch = output.match(/\{[\s\S]*\}/);
+    if (!jsonMatch) {
+      throw new Error("Could not extract JSON from Claude output");
+    }
+    const parsed = JSON.parse(jsonMatch[0]);
+    const msgMap = new Map(digest.rawMessages.map((m) => [m.id, m]));
+    const items = parsed.items.map((item) => {
+      const msg = msgMap.get(item.emailId);
+      if (!msg) return null;
+      return {
+        emailId: msg.id,
+        threadId: msg.threadId,
+        subject: msg.subject,
+        sender: msg.sender,
+        senderEmail: msg.senderEmail,
+        date: msg.date,
+        snippet: msg.snippet,
+        isRelevant: item.isRelevant,
+        relevanceReason: item.relevanceReason,
+        archived: false
+      };
+    }).filter((item) => item !== null);
+    yield api.post(`/api/email-digest/${digest.id}/complete`, {
+      summary: parsed.summary,
+      items
+    });
+    logOk(
+      `${paint4("yellow", sid)} done \u2014 ${paint4("green", String(items.filter((i) => i.isRelevant).length))} relevant, ${paint4("gray", String(items.filter((i) => !i.isRelevant).length))} not relevant`
+    );
+  });
+}
+function generateDigest() {
+  return __async(this, null, function* () {
+    let result;
+    try {
+      result = yield api.post("/api/email-digest/generate");
+    } catch (err) {
+      logErr(`Auto-generate failed: ${err.message}`);
+      return;
+    }
+    if (result.needsReauth) {
+      logErr("Auto-generate skipped: Gmail re-authentication required");
+      return;
+    }
+    if (result.status === "completed") {
+      log(`Auto-generated digest ${paint4("yellow", shortId2(result.id))} \u2014 no new emails`);
+    } else {
+      log(`Auto-generated digest ${paint4("yellow", shortId2(result.id))} \u2014 queued for processing`);
+    }
+  });
+}
+var digestCommand = new Command13("digest").description("Process pending email digests using Claude Code (run alongside mr watch)").option("--interval <seconds>", "Polling interval in seconds", "15").option("--generate-interval <seconds>", "How often to auto-generate new digests", "3600").option("--once", "Process pending digests once and exit", false).action((opts) => __async(null, null, function* () {
+  const intervalMs = parseInt(opts.interval, 10) * 1e3;
+  const generateIntervalMs = parseInt(opts.generateInterval, 10) * 1e3;
+  const once = opts.once;
+  const processing = /* @__PURE__ */ new Set();
+  const banner = [
+    ``,
+    paint4("magenta", `  \u2554\u2566\u2557\u2566\u2550\u2557  \u2554\u2566\u2557\u2566\u2554\u2550\u2557\u2554\u2550\u2557\u2554\u2550\u2557\u2554\u2566\u2557`),
+    paint4("magenta", `  \u2551\u2551\u2551\u2560\u2566\u255D   \u2551\u2551\u2551\u2551 \u2566\u2551\u2563 \u255A\u2550\u2557 \u2551`),
+    paint4("magenta", `  \u2569 \u2569\u2569\u255A\u2550  \u2550\u2569\u255D\u2569\u255A\u2550\u255D\u255A\u2550\u255D\u255A\u2550\u255D \u2569`),
+    paint4("dim", `  \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500`),
+    paint4("dim", `  email digest processor \xB7 powered by claude`),
+    ``
+  ].join("\n");
+  console.log(banner);
+  console.log(
+    `  interval=${paint4("cyan", opts.interval + "s")}  generate-interval=${paint4("cyan", opts.generateInterval + "s")}${once ? `  ${paint4("yellow", "once")}` : ""}
+`
+  );
+  function poll() {
+    return __async(this, null, function* () {
+      let pending;
+      try {
+        pending = yield api.get("/api/email-digest/pending");
+      } catch (err) {
+        logErr(`Failed to fetch pending digests: ${err.message}`);
+        return;
+      }
+      if (pending.length === 0) return;
+      log(`Found ${paint4("cyan", String(pending.length))} pending digest(s)`);
+      for (const digest of pending) {
+        if (processing.has(digest.id)) continue;
+        processing.add(digest.id);
+        processDigest(digest).catch((err) => logErr(`${shortId2(digest.id)} failed: ${err.message}`)).finally(() => processing.delete(digest.id));
+      }
+    });
+  }
+  process.on("SIGINT", () => {
+    console.log(`
+${timestamp2()} ${digestTag()} Shutting down\u2026`);
+    process.exit(0);
+  });
+  yield generateDigest();
+  yield poll();
+  if (once) {
+    const wait = () => new Promise((resolve3) => {
+      if (processing.size === 0) return resolve3();
+      const check = setInterval(() => {
+        if (processing.size === 0) {
+          clearInterval(check);
+          resolve3();
+        }
+      }, 500);
+    });
+    yield wait();
+  } else {
+    setInterval(poll, intervalMs);
+    setInterval(generateDigest, generateIntervalMs);
+  }
+}));
+
+// commands/up.ts
+import { Command as Command14 } from "commander";
+import { spawn as spawn4 } from "child_process";
+import { resolve as resolve2 } from "path";
+import { fileURLToPath } from "url";
+var c5 = {
+  reset: "\x1B[0m",
+  bold: "\x1B[1m",
+  dim: "\x1B[2m",
+  cyan: "\x1B[36m",
+  green: "\x1B[32m",
+  yellow: "\x1B[33m",
+  red: "\x1B[31m",
+  magenta: "\x1B[35m",
+  gray: "\x1B[90m"
+};
+function paint5(color, text) {
+  return `${c5[color]}${text}${c5.reset}`;
+}
+function timestamp3() {
+  return paint5("gray", (/* @__PURE__ */ new Date()).toLocaleTimeString("en-US", { hour12: false }));
+}
+function upTag() {
+  return paint5("cyan", "[up]");
+}
+function log2(msg) {
+  console.log(`${timestamp3()} ${upTag()} ${msg}`);
+}
+function logErr2(msg) {
+  console.error(`${timestamp3()} ${upTag()} ${paint5("red", "\u2717")} ${msg}`);
+}
+function spawnMr(args) {
+  const entry = process.argv[1];
+  const child = spawn4(process.execPath, [entry, ...args], {
+    stdio: ["ignore", "pipe", "pipe"]
+  });
+  return child;
+}
+var upCommand = new Command14("up").description("Run mr watch and mr digest together with a single command").option("--interval <seconds>", "Polling interval for both watch and digest", "15").option("--watch-interval <seconds>", "Override polling interval for mr watch").option("--digest-interval <seconds>", "Override polling interval for mr digest").option("--dry-run", "Pass --dry-run to mr watch", false).option("--plan-approval", "Pass --plan-approval to mr watch", false).option("--root <dir>", "Pass --root to mr watch (default: cwd)").action((opts) => {
+  var _a, _b, _c, _d;
+  const watchInterval = (_a = opts.watchInterval) != null ? _a : opts.interval;
+  const digestInterval = (_b = opts.digestInterval) != null ? _b : opts.interval;
+  const watchArgs = ["watch", "--interval", watchInterval];
+  if (opts.dryRun) watchArgs.push("--dry-run");
+  if (opts.planApproval) watchArgs.push("--plan-approval");
+  if (opts.root) watchArgs.push("--root", opts.root);
+  const digestArgs = ["digest", "--interval", digestInterval];
+  const banner = [
+    ``,
+    paint5("cyan", `  \u2554\u2566\u2557\u2566\u2550\u2557  \u2566 \u2566\u2554\u2550\u2557`),
+    paint5("magenta", `  \u2551\u2551\u2551\u2560\u2566\u255D  \u2551 \u2551\u2560\u2550\u255D`),
+    paint5("cyan", `  \u2569 \u2569\u2569\u255A\u2550  \u255A\u2550\u255D\u2569  `),
+    paint5("dim", `  \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500`),
+    paint5("dim", `  mr watch + mr digest \xB7 powered by claude`),
+    ``
+  ].join("\n");
+  console.log(banner);
+  const flags = [
+    `watch-interval=${paint5("cyan", watchInterval + "s")}`,
+    `digest-interval=${paint5("cyan", digestInterval + "s")}`,
+    ...opts.dryRun ? [paint5("yellow", "dry-run")] : [],
+    ...opts.planApproval ? [paint5("yellow", "plan-approval")] : [],
+    ...opts.root ? [`root=${paint5("cyan", resolve2(opts.root))}`] : []
+  ].join("  ");
+  console.log(`  ${flags}
+`);
+  const watchProc = spawnMr(watchArgs);
+  const digestProc = spawnMr(digestArgs);
+  for (const [proc, label] of [[watchProc, "watch"], [digestProc, "digest"]]) {
+    (_c = proc.stdout) == null ? void 0 : _c.on("data", (d) => process.stdout.write(d));
+    (_d = proc.stderr) == null ? void 0 : _d.on("data", (d) => process.stderr.write(d));
+    proc.on("exit", (code, signal) => {
+      if (signal !== "SIGTERM" && signal !== "SIGINT") {
+        logErr2(`mr ${label} exited unexpectedly (code=${code != null ? code : "?"}, signal=${signal != null ? signal : "none"})`);
+      }
+    });
+  }
+  function shutdown() {
+    log2("Shutting down\u2026");
+    watchProc.kill("SIGTERM");
+    digestProc.kill("SIGTERM");
+    setTimeout(() => process.exit(0), 500);
+  }
+  process.on("SIGINT", shutdown);
+  process.on("SIGTERM", shutdown);
+});
+
+// index.ts
+var program = new Command15();
+program.name("mr").description("Mr. Manager - Task and project management CLI").version("0.1.0");
+program.addCommand(initCommand);
+program.addCommand(authCommand);
+program.addCommand(loginCommand);
+program.addCommand(projectsCommand);
+program.addCommand(tasksCommand);
+program.addCommand(linkCommand);
+program.addCommand(unlinkCommand);
+program.addCommand(contextCommand);
+program.addCommand(watchCommand);
+program.addCommand(startCommand);
+program.addCommand(delegateCommand);
+program.addCommand(createCommand);
+program.addCommand(completeCommand);
+program.addCommand(subtaskCompleteCommand);
+program.addCommand(digestCommand);
+program.addCommand(upCommand);
+program.parse();