@promptprojectmanager/mcp-server 4.5.7 → 4.6.0

package/dist/index.js

@@ -1,14 +1,4 @@
 #!/usr/bin/env node
-import {
-  getLogFile,
-  getWatcherDir,
-  isProcessRunning,
-  isWatcherRunning,
-  readPid,
-  readStatus,
-  removePid,
-  writeStatus
-} from "./chunk-ATAMNB7A.js";
 
 // src/index.ts
 import minimist from "minimist";
@@ -111,168 +101,258 @@ function parseWatcherStartArgs(args) {
   };
 }
 
+// src/watcher/watcher_state.ts
+import { existsSync, mkdirSync, readFileSync, writeFileSync, unlinkSync } from "fs";
+import { join } from "path";
+function getWatcherDir(workingDirectory) {
+  const dir = join(workingDirectory, ".ppm", "yolo");
+  if (!existsSync(dir)) {
+    mkdirSync(dir, { recursive: true });
+  }
+  return dir;
+}
+function getStatusFile(workingDirectory) {
+  return join(getWatcherDir(workingDirectory), "status.json");
+}
+function writeStatus(workingDirectory, status) {
+  const statusFile = getStatusFile(workingDirectory);
+  writeFileSync(statusFile, JSON.stringify(status, null, 2), "utf-8");
+}
+function readStatus(workingDirectory) {
+  const statusFile = getStatusFile(workingDirectory);
+  if (!existsSync(statusFile)) {
+    return void 0;
+  }
+  try {
+    const content = readFileSync(statusFile, "utf-8");
+    return JSON.parse(content);
+  } catch {
+    return void 0;
+  }
+}
+
+// src/watcher/watcher_orchestrator.ts
+function buildOrchestratorInstructions(config, pendingTickets) {
+  const pollIntervalSec = Math.round(config.pollIntervalMs / 1e3);
+  return `# \u{1F916} YOLO Orchestrator Active
+
+You are now the **YOLO Orchestrator** for project \`${config.projectSlug}\`.
+
+## Current Configuration
+- **Poll Interval**: ${pollIntervalSec}s
+- **Max Parallel**: ${config.maxParallel}
+- **Ticket Timeout**: ${Math.round(config.ticketTimeout / 1e3 / 60)} minutes
+- **Working Directory**: ${config.workingDirectory}
+
+## Pending YOLO Tickets
+${pendingTickets.length > 0 ? formatPendingTickets(pendingTickets) : "_No tickets with YOLO flag currently in queue._"}
+
+## Your Job
+
+${pendingTickets.length > 0 ? `
+### \u{1F4E5} Execute Pending Tickets
+
+For each pending ticket above:
+
+1. **Claim it** using \`tickets_work\` with the ticket slug
+2. **Spawn a Task sub-agent** to execute it:
+   \`\`\`
+   Task tool with:
+   - subagent_type: "general-purpose"
+   - prompt: The ticket content (what needs to be done)
+   - run_in_background: true (for parallel execution)
+   \`\`\`
+3. **Report** the result when the sub-agent completes
+
+### Sub-Agent Prompt Template
+
+When spawning a sub-agent, use this prompt structure:
+
+\`\`\`
+Execute this ticket autonomously:
+
+## Ticket: {ticketSlug}
+
+{ticketContent}
+
+---
+
+When complete:
+1. Use \`tickets_close\` to close the ticket with slug "{ticketSlug}"
+2. Provide a brief summary of what was accomplished
+
+If you encounter blocking issues, use \`tickets_update\` to log your findings.
+\`\`\`
+` : `
+### \u{1F504} No Tickets Ready
+
+No YOLO tickets are currently pending. You can:
+- Say **"poll"** or **"check"** to refresh the ticket list
+- Say **"stop"** to exit orchestrator mode
+- Wait for tickets to be flagged with YOLO in the PPM UI
+`}
+
+## Commands
+
+- **"poll"** or **"continue"** - Check for new YOLO tickets
+- **"status"** - Show current orchestrator status
+- **"stop"** or **"exit"** - Stop the orchestrator
+
+## Status Tracking
+
+Use \`tickets_yolo_status\` to:
+- See pending YOLO tickets
+- Check currently executing tickets
+- View processed ticket count
+
+---
+
+_Orchestrator started at ${(/* @__PURE__ */ new Date()).toISOString()}_
+_Say "poll" to check for tickets, "stop" to exit._`;
+}
+function formatPendingTickets(tickets) {
+  return tickets.map((t, i) => {
+    const num = t.ticketNumber ? `#${t.ticketNumber}` : "";
+    const title = t.slug;
+    const preview = t.content.slice(0, 100).replace(/\n/g, " ");
+    return `${i + 1}. **${num} ${title}**
+   _${preview}${t.content.length > 100 ? "..." : ""}_`;
+  }).join("\n\n");
+}
+function formatOrchestratorStatus(status, pendingTickets) {
+  if (!status) {
+    return `# YOLO Orchestrator Status
+
+**State**: Not started
+
+_Use \`tickets_yolo_start\` to begin orchestration._`;
+  }
+  const lines = [
+    "# YOLO Orchestrator Status",
+    "",
+    `**State**: ${status.state}`,
+    `**Project**: ${status.projectSlug}`
+  ];
+  if (status.startedAt) {
+    lines.push(`**Started**: ${status.startedAt}`);
+  }
+  if (status.lastPollAt) {
+    lines.push(`**Last Poll**: ${status.lastPollAt}`);
+  }
+  lines.push(`**Tickets Processed**: ${status.ticketsProcessed}`);
+  if (status.currentlyExecuting && status.currentlyExecuting.length > 0) {
+    lines.push("");
+    lines.push("## Currently Executing");
+    for (const exec of status.currentlyExecuting) {
+      const num = exec.ticketNumber ? `#${exec.ticketNumber}` : "";
+      const elapsed = getElapsedTime(exec.startedAt);
+      lines.push(`- **${num} ${exec.ticketSlug}** (${elapsed})`);
+    }
+  }
+  lines.push("");
+  lines.push("## Pending YOLO Tickets");
+  if (pendingTickets.length > 0) {
+    for (const ticket of pendingTickets) {
+      const num = ticket.ticketNumber ? `#${ticket.ticketNumber}` : "";
+      lines.push(`- **${num} ${ticket.slug}**`);
+    }
+  } else {
+    lines.push("_No tickets pending_");
+  }
+  return lines.join("\n");
+}
+function getElapsedTime(startedAt) {
+  const start = new Date(startedAt).getTime();
+  const elapsed = Date.now() - start;
+  const minutes = Math.floor(elapsed / 1e3 / 60);
+  const seconds = Math.floor(elapsed / 1e3 % 60);
+  if (minutes > 0) {
+    return `${minutes}m ${seconds}s`;
+  }
+  return `${seconds}s`;
+}
+
 // src/watcher/watcher_controller.ts
-import { spawn } from "child_process";
-import { openSync, appendFileSync } from "fs";
-import { dirname, join } from "path";
-import { fileURLToPath } from "url";
-async function startWatcher(baseConfig, args) {
+function startOrchestrator(baseConfig, args, pendingTickets) {
   const workingDirectory = args?.workingDirectory ?? baseConfig.workingDirectory;
-  if (isWatcherRunning(workingDirectory)) {
-    const existingPid = readPid(workingDirectory);
-    const existingStatus = readStatus(workingDirectory);
-    return {
-      success: true,
-      message: "Watcher is already running",
-      pid: existingPid,
-      alreadyRunning: true,
-      config: existingStatus?.config
-    };
-  }
-  const config = {
+  const orchestratorConfig = {
     projectSlug: baseConfig.projectSlug,
-    projectToken: baseConfig.projectToken,
-    convexUrl: baseConfig.convexUrl,
-    workingDirectory,
     pollIntervalMs: args?.pollIntervalMs ?? 3e4,
     maxParallel: args?.maxParallel ?? 1,
     ticketTimeout: args?.ticketTimeout ?? 18e5,
-    enableNotifications: args?.enableNotifications ?? true
+    workingDirectory
   };
-  const configJson = JSON.stringify(config);
-  const configBase64 = Buffer.from(configJson).toString("base64");
-  const daemonPath = getDaemonPath();
-  try {
-    getWatcherDir(workingDirectory);
-    const logFile = getLogFile(workingDirectory);
-    appendFileSync(logFile, `
---- Daemon starting at ${(/* @__PURE__ */ new Date()).toISOString()} ---
-`);
-    const logFd = openSync(logFile, "a");
-    const child = spawn(process.execPath, [daemonPath, "--config", configBase64], {
-      detached: true,
-      stdio: ["ignore", logFd, logFd],
-      // stdout & stderr → log file descriptor
-      cwd: workingDirectory
-    });
-    child.unref();
-    await new Promise((resolve) => setTimeout(resolve, 500));
-    const pid = readPid(workingDirectory);
-    if (pid && isProcessRunning(pid)) {
-      return {
-        success: true,
-        message: "Watcher started successfully",
-        pid,
-        alreadyRunning: false,
-        config: {
-          projectSlug: config.projectSlug,
-          convexUrl: config.convexUrl,
-          pollIntervalMs: config.pollIntervalMs,
-          maxParallel: config.maxParallel,
-          ticketTimeout: config.ticketTimeout,
-          enableNotifications: config.enableNotifications,
-          workingDirectory: config.workingDirectory
-        }
-      };
-    } else {
-      return {
-        success: false,
-        message: "Daemon process started but failed to initialize. Check logs in .ppm/yolo/"
-      };
+  getWatcherDir(workingDirectory);
+  const initialStatus = {
+    state: "running",
+    projectSlug: baseConfig.projectSlug,
+    startedAt: (/* @__PURE__ */ new Date()).toISOString(),
+    ticketsProcessed: 0,
+    currentlyExecuting: [],
+    config: {
+      projectSlug: baseConfig.projectSlug,
+      convexUrl: baseConfig.convexUrl,
+      pollIntervalMs: orchestratorConfig.pollIntervalMs,
+      maxParallel: orchestratorConfig.maxParallel,
+      ticketTimeout: orchestratorConfig.ticketTimeout,
+      enableNotifications: args?.enableNotifications ?? true,
+      workingDirectory
     }
-  } catch (error) {
-    const errorMessage = error instanceof Error ? error.message : "Unknown error";
-    return {
-      success: false,
-      message: `Failed to start watcher: ${errorMessage}`
-    };
-  }
+  };
+  writeStatus(workingDirectory, initialStatus);
+  const instructions = buildOrchestratorInstructions(orchestratorConfig, pendingTickets);
+  return {
+    success: true,
+    message: "Orchestrator started",
+    instructions,
+    config: initialStatus.config,
+    alreadyRunning: false
+  };
 }
-async function stopWatcher(workingDirectory) {
-  const pid = readPid(workingDirectory);
-  if (!pid) {
+function stopOrchestrator(workingDirectory) {
+  const status = readStatus(workingDirectory);
+  if (!status) {
     return {
       success: true,
-      message: "No watcher is running",
+      message: "No orchestrator session found",
       wasRunning: false
     };
   }
-  if (!isProcessRunning(pid)) {
-    removePid(workingDirectory);
-    const status = readStatus(workingDirectory);
-    if (status) {
-      writeStatus(workingDirectory, { ...status, state: "stopped" });
-    }
+  if (status.state !== "running") {
     return {
       success: true,
-      message: "Watcher was not running (cleaned up stale PID file)",
+      message: `Orchestrator was already ${status.state}`,
       wasRunning: false
     };
   }
-  try {
-    process.kill(pid, "SIGTERM");
-    const maxWait = 5e3;
-    const checkInterval = 100;
-    let waited = 0;
-    while (waited < maxWait && isProcessRunning(pid)) {
-      await new Promise((resolve) => setTimeout(resolve, checkInterval));
-      waited += checkInterval;
-    }
-    if (isProcessRunning(pid)) {
-      try {
-        process.kill(pid, "SIGKILL");
-      } catch {
-      }
-    }
-    removePid(workingDirectory);
-    const status = readStatus(workingDirectory);
-    if (status) {
-      writeStatus(workingDirectory, { ...status, state: "stopped" });
-    }
-    return {
-      success: true,
-      message: "Watcher stopped successfully",
-      wasRunning: true
-    };
-  } catch (error) {
-    const errorMessage = error instanceof Error ? error.message : "Unknown error";
-    return {
-      success: false,
-      message: `Failed to stop watcher: ${errorMessage}`,
-      wasRunning: true
-    };
-  }
+  writeStatus(workingDirectory, {
+    ...status,
+    state: "stopped"
+  });
+  return {
+    success: true,
+    message: "Orchestrator stopped",
+    wasRunning: true
+  };
 }
-function getWatcherStatus(workingDirectory) {
+function getOrchestratorStatus(workingDirectory, pendingTickets) {
   const status = readStatus(workingDirectory);
+  const formattedStatus = formatOrchestratorStatus(status ?? null, pendingTickets);
   if (!status) {
     return {
       success: true,
-      message: "No watcher has been started for this project"
+      message: "No orchestrator session has been started for this project",
+      pendingTickets,
+      formattedStatus
     };
   }
-  if (status.state === "running" && status.pid) {
-    if (!isProcessRunning(status.pid)) {
-      const updatedStatus = { ...status, state: "stopped" };
-      writeStatus(workingDirectory, updatedStatus);
-      removePid(workingDirectory);
-      return {
-        success: true,
-        status: updatedStatus,
-        message: "Watcher process has stopped unexpectedly"
-      };
-    }
-  }
   return {
     success: true,
-    status
+    status,
+    pendingTickets,
+    formattedStatus
   };
 }
-function getDaemonPath() {
-  const currentFilePath = fileURLToPath(import.meta.url);
-  const currentDir = dirname(currentFilePath);
-  return join(currentDir, "watcher", "watcher_daemon.js");
-}
 
 // src/prompt-builder.ts
 var AmbiguousPromptError = class extends Error {
@@ -415,25 +495,25 @@ async function startServer(config, convexClientRaw) {
       projectSlug,
       type: "update"
     },
-    // YOLO watcher tools - autonomous ticket execution
+    // YOLO orchestrator tools - sub-agent based autonomous ticket execution
     {
       name: `tickets_yolo_start`,
       description: `Start the YOLO ticket watcher for "${projectSlug}". Polls for open tickets with yolo flag and spawns Terminal windows with Claude Code to execute them autonomously.`,
-      slashDescription: `Start YOLO watcher for autonomous ticket execution`,
+      slashDescription: `Start YOLO orchestrator for autonomous ticket execution`,
       projectSlug,
       type: "yolo_start"
     },
     {
       name: `tickets_yolo_stop`,
       description: `Stop the YOLO ticket watcher for "${projectSlug}"`,
-      slashDescription: `Stop the YOLO watcher daemon`,
+      slashDescription: `Stop the YOLO orchestrator`,
       projectSlug,
       type: "yolo_stop"
     },
     {
       name: `tickets_yolo_status`,
       description: `Get YOLO watcher status for "${projectSlug}"`,
-      slashDescription: `Check YOLO watcher status and metrics`,
+      slashDescription: `Check YOLO orchestrator status and pending tickets`,
       projectSlug,
       type: "yolo_status"
     }
@@ -1520,33 +1600,31 @@ _Ticket content has been appended with your update._`
         const args = parseWatcherStartArgs(request.params.arguments);
         const workingDirectory = args.workingDirectory ?? process.cwd();
         try {
-          const result = await startWatcher(
+          let pendingTickets = [];
+          try {
+            pendingTickets = await convexClient.query(
+              "mcp_tickets:listYoloTickets",
+              {
+                projectToken: config.projectToken,
+                projectSlug: ticketTool.projectSlug
+              }
+            );
+          } catch (queryError) {
+            console.error(`[MCP] Failed to query YOLO tickets:`, queryError);
+          }
+          const result = startOrchestrator(
             {
               projectSlug: ticketTool.projectSlug,
               projectToken: config.projectToken,
               convexUrl: config.convexUrl,
               workingDirectory
             },
-            args
+            args,
+            pendingTickets
           );
-          if (result.success) {
-            const statusLines = [
-              result.alreadyRunning ? `\u2139\uFE0F Watcher is already running (PID: ${result.pid})` : `\u2705 Watcher started (PID: ${result.pid})`
-            ];
-            if (result.config) {
-              statusLines.push("");
-              statusLines.push("**Configuration:**");
-              statusLines.push(`  Poll Interval: ${result.config.pollIntervalMs / 1e3}s`);
-              statusLines.push(`  Max Parallel: ${result.config.maxParallel}`);
-              statusLines.push(`  Ticket Timeout: ${result.config.ticketTimeout / 1e3 / 60} min`);
-              statusLines.push(`  Notifications: ${result.config.enableNotifications ? "enabled" : "disabled"}`);
-              statusLines.push(`  Working Directory: ${result.config.workingDirectory}`);
-            }
-            statusLines.push("");
-            statusLines.push("_The watcher will poll for open tickets with the YOLO flag and spawn Claude Code terminals to execute them._");
-            statusLines.push("_Use `tickets_yolo_status` to check progress, `tickets_yolo_stop` to stop._");
+          if (result.success && result.instructions) {
             return {
-              content: [{ type: "text", text: statusLines.join("\n") }]
+              content: [{ type: "text", text: result.instructions }]
             };
           } else {
             return {
@@ -1558,19 +1636,19 @@ _Ticket content has been appended with your update._`
           const errorMessage = error instanceof Error ? error.message : "Unknown error";
           console.error(`[MCP] tickets_yolo_start error:`, error);
           return {
-            content: [{ type: "text", text: `Error starting watcher: ${errorMessage}` }],
+            content: [{ type: "text", text: `Error starting orchestrator: ${errorMessage}` }],
             isError: true
           };
         }
       } else if (ticketTool.type === "yolo_stop") {
         const workingDirectory = process.cwd();
         try {
-          const result = await stopWatcher(workingDirectory);
+          const result = stopOrchestrator(workingDirectory);
           if (result.success) {
             return {
               content: [{
                 type: "text",
-                text: result.wasRunning ? `\u2705 Watcher stopped successfully` : `\u2139\uFE0F ${result.message}`
+                text: result.wasRunning ? `\u2705 Orchestrator stopped. You can stop processing tickets now.` : `\u2139\uFE0F ${result.message}`
               }]
             };
           } else {
@@ -1583,62 +1661,39 @@ _Ticket content has been appended with your update._`
           const errorMessage = error instanceof Error ? error.message : "Unknown error";
           console.error(`[MCP] tickets_yolo_stop error:`, error);
           return {
-            content: [{ type: "text", text: `Error stopping watcher: ${errorMessage}` }],
+            content: [{ type: "text", text: `Error stopping orchestrator: ${errorMessage}` }],
             isError: true
           };
         }
       } else if (ticketTool.type === "yolo_status") {
         const workingDirectory = process.cwd();
         try {
-          const result = getWatcherStatus(workingDirectory);
-          if (!result.status) {
+          let pendingTickets = [];
+          try {
+            pendingTickets = await convexClient.query(
+              "mcp_tickets:listYoloTickets",
+              {
+                projectToken: config.projectToken,
+                projectSlug: ticketTool.projectSlug
+              }
+            );
+          } catch (queryError) {
+            console.error(`[MCP] Failed to query YOLO tickets:`, queryError);
+          }
+          const result = getOrchestratorStatus(workingDirectory, pendingTickets);
+          if (result.formattedStatus) {
             return {
-              content: [{ type: "text", text: `\u2139\uFE0F ${result.message ?? "No watcher status available"}` }]
+              content: [{ type: "text", text: result.formattedStatus }]
             };
           }
-          const status = result.status;
-          const lines = [
-            `# YOLO Watcher Status: ${status.projectSlug}`,
-            "",
-            `**State:** ${status.state.toUpperCase()}`
-          ];
-          if (status.pid) {
-            lines.push(`**PID:** ${status.pid}`);
-          }
-          if (status.startedAt) {
-            lines.push(`**Started:** ${status.startedAt}`);
-          }
-          if (status.lastPollAt) {
-            lines.push(`**Last Poll:** ${status.lastPollAt}`);
-          }
-          lines.push(`**Tickets Processed:** ${status.ticketsProcessed}`);
-          if (status.currentlyExecuting && status.currentlyExecuting.length > 0) {
-            lines.push("");
-            lines.push("**Currently Executing:**");
-            for (const exec of status.currentlyExecuting) {
-              const displayName = exec.ticketNumber ? `#${exec.ticketNumber} ${exec.ticketSlug}` : exec.ticketSlug;
-              lines.push(`  \u2022 ${displayName} (started: ${exec.startedAt})`);
-            }
-          }
-          if (status.lastError) {
-            lines.push("");
-            lines.push(`**Last Error:** ${status.lastError}`);
-          }
-          if (status.config) {
-            lines.push("");
-            lines.push("**Configuration:**");
-            lines.push(`  Poll Interval: ${status.config.pollIntervalMs / 1e3}s`);
-            lines.push(`  Max Parallel: ${status.config.maxParallel}`);
-            lines.push(`  Working Directory: ${status.config.workingDirectory}`);
-          }
           return {
-            content: [{ type: "text", text: lines.join("\n") }]
+            content: [{ type: "text", text: `\u2139\uFE0F ${result.message ?? "No orchestrator status available"}` }]
           };
         } catch (error) {
           const errorMessage = error instanceof Error ? error.message : "Unknown error";
           console.error(`[MCP] tickets_yolo_status error:`, error);
           return {
-            content: [{ type: "text", text: `Error getting watcher status: ${errorMessage}` }],
+            content: [{ type: "text", text: `Error getting orchestrator status: ${errorMessage}` }],
             isError: true
           };
         }