ralph-mcp 1.0.9 → 1.0.10

package/dist/tools/batch-start.js

@@ -5,6 +5,7 @@ import { execSync } from "child_process";
 import { parsePrdFile } from "../utils/prd-parser.js";
 import { createWorktree } from "../utils/worktree.js";
 import { generateAgentPrompt } from "../utils/agent.js";
+import { detectPackageManager, getInstallCommand, } from "../utils/package-manager.js";
 import { areDependenciesSatisfied, findExecutionByBranch, insertExecution, insertUserStories, } from "../store/state.js";
 export const batchStartInputSchema = z.object({
     prdPaths: z.array(z.string()).describe("Array of paths to PRD markdown files"),
@@ -20,7 +21,7 @@ export const batchStartInputSchema = z.object({
         .string()
         .optional()
         .describe("Path to a file (e.g., CLAUDE.md) to inject into the agent prompt"),
-    preheat: z.boolean().default(true).describe("Run pnpm install serially before starting agents (avoids store lock)"),
+    preheat: z.boolean().default(true).describe("Run install command serially before starting agents (avoids store lock)"),
 });
 /**
  * Topological sort to determine execution order based on dependencies.
@@ -53,23 +54,30 @@ function topologicalSort(prds) {
     return result;
 }
 /**
- * Run pnpm install in a worktree directory.
+ * Run install command in a worktree directory.
  */
-function preheatWorktree(worktreePath) {
+function preheatWorktree(worktreePath, installCmd) {
+    const cmd = `${installCmd.command} ${installCmd.args.join(" ")}`;
     try {
-        execSync("pnpm install --frozen-lockfile", {
+        execSync(cmd, {
             cwd: worktreePath,
             stdio: "pipe",
             timeout: 300000, // 5 minutes
         });
     }
     catch (error) {
-        // Try without frozen lockfile
-        execSync("pnpm install", {
-            cwd: worktreePath,
-            stdio: "pipe",
-            timeout: 300000,
-        });
+        // Try fallback if available
+        if (installCmd.fallbackArgs.length > 0) {
+            const fallbackCmd = `${installCmd.command} ${installCmd.fallbackArgs.join(" ")}`;
+            execSync(fallbackCmd, {
+                cwd: worktreePath,
+                stdio: "pipe",
+                timeout: 300000,
+            });
+        }
+        else {
+            throw error;
+        }
     }
 }
 export async function batchStart(input) {
@@ -78,6 +86,9 @@ export async function batchStart(input) {
     const contextPath = input.contextInjectionPath
         ? resolve(projectRoot, input.contextInjectionPath)
         : undefined;
+    // Detect package manager
+    const pm = detectPackageManager(projectRoot);
+    const installCmd = getInstallCommand(pm);
     const skipped = [];
     const prdInfos = [];
     // Phase 1: Parse all PRDs and create execution records
@@ -159,13 +170,13 @@ export async function batchStart(input) {
     }
     // Phase 2: Topological sort for preheat order
     const sortedPrds = topologicalSort(prdInfos);
-    // Phase 3: Preheat worktrees serially (avoids pnpm store lock contention)
+    // Phase 3: Preheat worktrees serially (avoids store lock contention)
     let preheatCompleted = false;
     if (input.preheat && input.worktree) {
         for (const prd of sortedPrds) {
             if (prd.worktreePath) {
                 try {
-                    preheatWorktree(prd.worktreePath);
+                    preheatWorktree(prd.worktreePath, installCmd);
                 }
                 catch (error) {
                     console.error(`Preheat failed for ${prd.branch}:`, error);

package/dist/utils/package-manager.d.ts

@@ -0,0 +1,8 @@
+export type PackageManager = "pnpm" | "npm" | "yarn" | "bun";
+export interface InstallCommand {
+    command: string;
+    args: string[];
+    fallbackArgs: string[];
+}
+export declare function detectPackageManager(projectRoot: string): PackageManager;
+export declare function getInstallCommand(pm: PackageManager): InstallCommand;

package/dist/utils/package-manager.js

@@ -0,0 +1,44 @@
+import { existsSync } from "fs";
+import { join } from "path";
+export function detectPackageManager(projectRoot) {
+    if (existsSync(join(projectRoot, "pnpm-lock.yaml"))) {
+        return "pnpm";
+    }
+    if (existsSync(join(projectRoot, "yarn.lock"))) {
+        return "yarn";
+    }
+    if (existsSync(join(projectRoot, "bun.lockb"))) {
+        return "bun";
+    }
+    // Default to npm if package-lock.json exists or as fallback
+    return "npm";
+}
+export function getInstallCommand(pm) {
+    switch (pm) {
+        case "pnpm":
+            return {
+                command: "pnpm",
+                args: ["install", "--frozen-lockfile"],
+                fallbackArgs: ["install"],
+            };
+        case "yarn":
+            return {
+                command: "yarn",
+                args: ["install", "--frozen-lockfile"],
+                fallbackArgs: ["install"],
+            };
+        case "bun":
+            return {
+                command: "bun",
+                args: ["install", "--frozen-lockfile"],
+                fallbackArgs: ["install"],
+            };
+        case "npm":
+        default:
+            return {
+                command: "npm",
+                args: ["ci"],
+                fallbackArgs: ["install"],
+            };
+    }
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "ralph-mcp",
-  "version": "1.0.9",
+  "version": "1.0.10",
   "description": "MCP server for autonomous PRD execution with Claude Code. Git worktree isolation, progress tracking, auto-merge.",
   "type": "module",
   "main": "dist/index.js",