ralphflow 0.2.0 → 0.3.0

package/dist/ralphflow.js

@@ -141,7 +141,7 @@ import { Command as Command2 } from "commander";
 import chalk4 from "chalk";
 
 // src/core/runner.ts
-import { readFileSync as readFileSync3 } from "fs";
+import { readFileSync as readFileSync3, existsSync as existsSync4, mkdirSync as mkdirSync2, writeFileSync, readdirSync as readdirSync3, unlinkSync } from "fs";
 import { join as join4 } from "path";
 import chalk3 from "chalk";
 
@@ -229,55 +229,23 @@ function resolveLoop(config, name) {
 // src/core/claude.ts
 import { spawn } from "child_process";
 async function spawnClaude(options) {
-  const { prompt, model, printMode = false, agentName, cwd } = options;
-  const args = [];
-  if (printMode) {
-    args.push("-p");
-    args.push("--dangerously-skip-permissions");
-  }
+  const { prompt, model, cwd } = options;
+  const args = ["--dangerously-skip-permissions", prompt];
   if (model) {
-    args.push("--model", model);
+    args.unshift("--model", model);
   }
   return new Promise((resolve, reject) => {
     const child = spawn("claude", args, {
       cwd,
-      stdio: printMode ? ["pipe", "pipe", "pipe"] : ["pipe", "pipe", "inherit"],
+      stdio: "inherit",
       env: { ...process.env }
     });
-    let output = "";
-    child.stdout?.on("data", (data) => {
-      const text = data.toString();
-      output += text;
-      if (agentName) {
-        const lines = text.split("\n");
-        for (const line of lines) {
-          if (line) {
-            process.stdout.write(`[${agentName}] ${line}
-`);
-          }
-        }
-      } else {
-        process.stdout.write(text);
-      }
-    });
-    if (printMode && child.stderr) {
-      child.stderr.on("data", (data) => {
-        const text = data.toString();
-        if (agentName) {
-          process.stderr.write(`[${agentName}] ${text}`);
-        } else {
-          process.stderr.write(text);
-        }
-      });
-    }
-    child.stdin?.write(prompt);
-    child.stdin?.end();
     child.on("error", (err) => {
       reject(new Error(`Failed to spawn claude: ${err.message}`));
     });
     child.on("close", (code, signal) => {
       resolve({
-        output,
+        output: "",
         exitCode: code,
         signal
       });
@@ -286,41 +254,104 @@ async function spawnClaude(options) {
 }
 
 // src/core/runner.ts
-var AGENT_COLORS = [
-  chalk3.cyan,
-  chalk3.magenta,
-  chalk3.yellow,
-  chalk3.green,
-  chalk3.blue,
-  chalk3.red
-];
+function agentsDir(flowDir, loop) {
+  const loopDir = join4(flowDir, loop.tracker, "..");
+  return join4(loopDir, ".agents");
+}
+function isProcessAlive(pid) {
+  try {
+    process.kill(pid, 0);
+    return true;
+  } catch {
+    return false;
+  }
+}
+function cleanStaleAgents(dir) {
+  if (!existsSync4(dir)) return;
+  for (const file of readdirSync3(dir)) {
+    if (!file.endsWith(".lock")) continue;
+    const pidStr = readFileSync3(join4(dir, file), "utf-8").trim();
+    const pid = parseInt(pidStr, 10);
+    if (isNaN(pid) || !isProcessAlive(pid)) {
+      unlinkSync(join4(dir, file));
+    }
+  }
+}
+function acquireAgentId(dir, maxAgents) {
+  mkdirSync2(dir, { recursive: true });
+  cleanStaleAgents(dir);
+  for (let n = 1; n <= maxAgents; n++) {
+    const lockFile = join4(dir, `agent-${n}.lock`);
+    if (!existsSync4(lockFile)) {
+      writeFileSync(lockFile, String(process.pid));
+      return `agent-${n}`;
+    }
+  }
+  throw new Error(`All ${maxAgents} agent slots are occupied. Wait for one to finish or increase max_agents.`);
+}
+function releaseAgentId(dir, agentName) {
+  const lockFile = join4(dir, `${agentName}.lock`);
+  try {
+    unlinkSync(lockFile);
+  } catch {
+  }
+}
+function checkTrackerForCompletion(flowDir, loop) {
+  const trackerPath = join4(flowDir, loop.tracker);
+  if (!existsSync4(trackerPath)) return false;
+  const content = readFileSync3(trackerPath, "utf-8");
+  return content.includes(`<promise>${loop.completion}</promise>`);
+}
 async function runLoop(loopName, options) {
   const flowDir = resolveFlowDir(options.cwd, options.flow);
   const config = loadConfig(flowDir);
   const { key, loop } = resolveLoop(config, loopName);
-  const isMultiAgent = options.agents > 1 && loop.multi_agent !== false;
+  let agentName;
+  let agentDir;
+  if (options.multiAgent) {
+    if (loop.multi_agent === false) {
+      throw new Error(`Loop "${loop.name}" does not support multi-agent mode.`);
+    }
+    const ma = loop.multi_agent;
+    agentDir = agentsDir(flowDir, loop);
+    agentName = acquireAgentId(agentDir, ma.max_agents);
+  }
   console.log();
   console.log(
-    chalk3.bold(`  RalphFlow \u2014 ${loop.name}`) + (isMultiAgent ? chalk3.dim(` (${options.agents} agents)`) : "")
+    chalk3.bold(`  RalphFlow \u2014 ${loop.name}`) + (agentName ? chalk3.dim(` [${agentName}]`) : "")
   );
   console.log();
-  if (isMultiAgent) {
-    await runMultiAgent(loop, flowDir, options);
-  } else {
-    await runSingleAgent(loop, flowDir, options);
+  const cleanup = () => {
+    if (agentDir && agentName) {
+      releaseAgentId(agentDir, agentName);
+    }
+  };
+  process.on("exit", cleanup);
+  process.on("SIGINT", () => {
+    cleanup();
+    process.exit(130);
+  });
+  process.on("SIGTERM", () => {
+    cleanup();
+    process.exit(143);
+  });
+  try {
+    await iterationLoop(loop, flowDir, options, agentName);
+  } finally {
+    cleanup();
   }
 }
-async function runSingleAgent(loop, flowDir, options) {
+async function iterationLoop(loop, flowDir, options, agentName) {
   for (let i = 1; i <= options.maxIterations; i++) {
-    console.log(chalk3.dim(`  Iteration ${i}/${options.maxIterations}`));
-    const prompt = readPrompt(loop, flowDir, options.agentName);
+    const label = agentName ? chalk3.dim(`  [${agentName}] Iteration ${i}/${options.maxIterations}`) : chalk3.dim(`  Iteration ${i}/${options.maxIterations}`);
+    console.log(label);
+    const prompt = readPrompt(loop, flowDir, agentName);
     const result = await spawnClaude({
       prompt,
       model: options.model,
-      printMode: false,
       cwd: options.cwd
     });
-    if (result.output.includes(`<promise>${loop.completion}</promise>`)) {
+    if (checkTrackerForCompletion(flowDir, loop)) {
       console.log();
       console.log(chalk3.green(`  Loop complete: ${loop.completion}`));
       return;
@@ -330,64 +361,15 @@ async function runSingleAgent(loop, flowDir, options) {
       console.log();
       continue;
     }
-    if (result.exitCode !== 0 && result.exitCode !== null) {
-      console.log(chalk3.red(`  Claude exited with code ${result.exitCode}`));
-      return;
-    }
-    console.log(chalk3.dim(`  Iteration ${i} finished, continuing...`));
-    console.log();
-  }
-  console.log(chalk3.yellow(`  Max iterations (${options.maxIterations}) reached.`));
-}
-async function runMultiAgent(loop, flowDir, options) {
-  const agentCount = options.agents;
-  let completed = false;
-  const agentRunners = Array.from({ length: agentCount }, (_, idx) => {
-    const agentNum = idx + 1;
-    const agentName = `agent-${agentNum}`;
-    const colorFn = AGENT_COLORS[idx % AGENT_COLORS.length];
-    return runAgentLoop(loop, flowDir, {
-      ...options,
-      agentName
-    }, colorFn, () => completed, () => {
-      completed = true;
-    });
-  });
-  await Promise.allSettled(agentRunners);
-  console.log();
-  console.log(chalk3.green(`  All agents finished.`));
-}
-async function runAgentLoop(loop, flowDir, options, colorFn, isCompleted, setCompleted) {
-  const agentName = options.agentName;
-  for (let i = 1; i <= options.maxIterations; i++) {
-    if (isCompleted()) {
-      console.log(colorFn(`  [${agentName}] Stopping \u2014 completion detected.`));
-      return;
-    }
-    console.log(colorFn(`  [${agentName}] Iteration ${i}/${options.maxIterations}`));
-    const prompt = readPrompt(loop, flowDir, agentName);
-    const result = await spawnClaude({
-      prompt,
-      model: options.model,
-      printMode: true,
-      agentName,
-      cwd: options.cwd
-    });
-    if (result.output.includes(`<promise>${loop.completion}</promise>`)) {
-      console.log(colorFn(`  [${agentName}] Loop complete: ${loop.completion}`));
-      setCompleted();
-      return;
-    }
-    if (result.signal === "SIGINT" || result.exitCode === 130) {
-      console.log(colorFn(`  [${agentName}] Iteration ${i} complete, restarting...`));
+    if (result.exitCode === 0 || result.exitCode === null) {
+      console.log(chalk3.dim(`  Iteration ${i} finished, continuing...`));
+      console.log();
       continue;
     }
-    if (result.exitCode !== 0 && result.exitCode !== null) {
-      console.log(chalk3.red(`  [${agentName}] Claude exited with code ${result.exitCode}`));
-      return;
-    }
+    console.log(chalk3.red(`  Claude exited with code ${result.exitCode}`));
+    return;
   }
-  console.log(chalk3.yellow(`  [${agentName}] Max iterations reached.`));
+  console.log(chalk3.yellow(`  Max iterations (${options.maxIterations}) reached.`));
 }
 function readPrompt(loop, flowDir, agentName) {
   const promptPath = join4(flowDir, loop.prompt);
@@ -402,10 +384,10 @@ function readPrompt(loop, flowDir, agentName) {
 }
 
 // src/cli/run.ts
-var runCommand = new Command2("run").description("Run a loop").argument("<loop>", "Loop to run (story, tasks, delivery, discovery, research, document)").option("-a, --agents <n>", "Number of parallel agents", "1").option("-m, --model <model>", "Claude model to use").option("-n, --max-iterations <n>", "Maximum iterations", "30").option("-f, --flow <name>", "Which flow to run (auto-detected if only one)").action(async (loop, opts) => {
+var runCommand = new Command2("run").description("Run a loop").argument("<loop>", "Loop to run (story, tasks, delivery, discovery, research, document)").option("--multi-agent", "Run as a multi-agent instance (auto-assigns agent ID)").option("-m, --model <model>", "Claude model to use").option("-n, --max-iterations <n>", "Maximum iterations", "30").option("-f, --flow <name>", "Which flow to run (auto-detected if only one)").action(async (loop, opts) => {
   try {
     await runLoop(loop, {
-      agents: parseInt(opts.agents, 10),
+      multiAgent: !!opts.multiAgent,
       model: opts.model,
       maxIterations: parseInt(opts.maxIterations, 10),
       flow: opts.flow,
@@ -425,7 +407,7 @@ import { Command as Command3 } from "commander";
 import chalk6 from "chalk";
 
 // src/core/status.ts
-import { readFileSync as readFileSync4, existsSync as existsSync4 } from "fs";
+import { readFileSync as readFileSync4, existsSync as existsSync5 } from "fs";
 import { join as join5 } from "path";
 import chalk5 from "chalk";
 import Table from "cli-table3";
@@ -502,7 +484,7 @@ function parseTracker(trackerPath, flowDir, loopName) {
     completed: 0,
     total: 0
   };
-  if (!existsSync4(fullPath)) {
+  if (!existsSync5(fullPath)) {
     return status;
   }
   const content = readFileSync4(fullPath, "utf-8");

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "ralphflow",
-  "version": "0.2.0",
+  "version": "0.3.0",
   "description": "Multi-agent AI workflow orchestration framework for Claude Code. Define pipelines as loops, coordinate parallel agents, and ship structured work.",
   "type": "module",
   "bin": {