ralphflow 0.3.0 → 0.5.0

package/dist/chunk-TCCMQDVT.js

@@ -0,0 +1,505 @@
+// src/core/template.ts
+import { readFileSync, writeFileSync, mkdirSync, cpSync, existsSync, readdirSync, rmSync } from "fs";
+import { join, dirname } from "path";
+import { fileURLToPath } from "url";
+import { stringify as stringifyYaml } from "yaml";
+var __dirname = dirname(fileURLToPath(import.meta.url));
+var BUILT_IN_TEMPLATES = ["code-implementation", "research"];
+function resolveTemplatePath(templateName) {
+  const candidates = [
+    join(__dirname, "..", "templates", templateName),
+    // dev: src/core/ -> src/templates/
+    join(__dirname, "..", "src", "templates", templateName)
+    // bundled: dist/ -> src/templates/
+  ];
+  for (const candidate of candidates) {
+    if (existsSync(candidate)) {
+      return candidate;
+    }
+  }
+  throw new Error(
+    `Template "${templateName}" not found. Searched:
+${candidates.join("\n")}`
+  );
+}
+function resolveTemplatePathWithCustom(templateName, cwd) {
+  const customPath = join(cwd, ".ralph-flow", ".templates", templateName);
+  if (existsSync(customPath) && existsSync(join(customPath, "ralphflow.yaml"))) {
+    return customPath;
+  }
+  return resolveTemplatePath(templateName);
+}
+function copyTemplate(templateName, targetDir, cwd) {
+  const templatePath = cwd ? resolveTemplatePathWithCustom(templateName, cwd) : resolveTemplatePath(templateName);
+  const loopsDir = join(templatePath, "loops");
+  if (!existsSync(loopsDir)) {
+    throw new Error(`Template "${templateName}" has no loops/ directory`);
+  }
+  mkdirSync(targetDir, { recursive: true });
+  cpSync(loopsDir, targetDir, { recursive: true });
+  const yamlSrc = join(templatePath, "ralphflow.yaml");
+  if (existsSync(yamlSrc)) {
+    const yamlDest = join(targetDir, "ralphflow.yaml");
+    cpSync(yamlSrc, yamlDest);
+  }
+}
+function validateTemplateName(name) {
+  if (!name || name.trim().length === 0) {
+    return { valid: false, error: "Template name is required" };
+  }
+  if (name.includes("..") || name.includes("/") || name.includes("\\")) {
+    return { valid: false, error: 'Invalid name: must not contain "..", "/", or "\\"' };
+  }
+  if (!/^[a-zA-Z0-9_-]+$/.test(name)) {
+    return { valid: false, error: "Only alphanumeric characters, hyphens, and underscores allowed" };
+  }
+  if (name.length > 50) {
+    return { valid: false, error: "Template name must be 50 characters or fewer" };
+  }
+  if (BUILT_IN_TEMPLATES.includes(name)) {
+    return { valid: false, error: `"${name}" is a reserved built-in template name` };
+  }
+  return { valid: true };
+}
+function listCustomTemplates(cwd) {
+  const customDir = join(cwd, ".ralph-flow", ".templates");
+  if (!existsSync(customDir)) return [];
+  return readdirSync(customDir, { withFileTypes: true }).filter((d) => d.isDirectory() && !d.name.startsWith(".")).filter((d) => existsSync(join(customDir, d.name, "ralphflow.yaml"))).map((d) => d.name);
+}
+function getAvailableTemplates(cwd) {
+  const results = [];
+  for (const name of BUILT_IN_TEMPLATES) {
+    try {
+      const templatePath = resolveTemplatePath(name);
+      const yamlPath = join(templatePath, "ralphflow.yaml");
+      const raw = readFileSync(yamlPath, "utf-8");
+      const descMatch = raw.match(/^description:\s*"?([^"\n]+)"?/m);
+      const loopMatches = raw.match(/^\s{2}\S+-loop:/gm);
+      results.push({
+        name,
+        type: "built-in",
+        description: descMatch?.[1] || "",
+        loopCount: loopMatches?.length || 0
+      });
+    } catch {
+      results.push({ name, type: "built-in", description: "", loopCount: 0 });
+    }
+  }
+  const customDir = join(cwd, ".ralph-flow", ".templates");
+  for (const tplName of listCustomTemplates(cwd)) {
+    try {
+      const yamlPath = join(customDir, tplName, "ralphflow.yaml");
+      const raw = readFileSync(yamlPath, "utf-8");
+      const descMatch = raw.match(/^description:\s*"?([^"\n]+)"?/m);
+      const loopMatches = raw.match(/^\s{2}\S+-loop:/gm);
+      results.push({
+        name: tplName,
+        type: "custom",
+        description: descMatch?.[1] || "",
+        loopCount: loopMatches?.length || 0
+      });
+    } catch {
+      results.push({ name: tplName, type: "custom", description: "", loopCount: 0 });
+    }
+  }
+  return results;
+}
+function createCustomTemplate(cwd, definition) {
+  const validation = validateTemplateName(definition.name);
+  if (!validation.valid) {
+    throw new Error(validation.error);
+  }
+  const customDir = join(cwd, ".ralph-flow", ".templates", definition.name);
+  if (existsSync(customDir)) {
+    throw new Error(`Template "${definition.name}" already exists`);
+  }
+  const config = {
+    name: definition.name,
+    description: definition.description || "",
+    version: 1,
+    dir: ".ralph-flow",
+    entities: {},
+    loops: {}
+  };
+  const loops = config.loops;
+  definition.loops.forEach((loopDef, index) => {
+    const baseKey = loopDef.name.toLowerCase().replace(/\s+/g, "-");
+    const loopKey = baseKey.endsWith("-loop") ? baseKey : `${baseKey}-loop`;
+    const dirPrefix = String(index).padStart(2, "0");
+    const loopDirName = `${dirPrefix}-${loopKey}`;
+    const loopConfig = {
+      order: index,
+      name: loopDef.name,
+      prompt: `${loopDirName}/prompt.md`,
+      tracker: `${loopDirName}/tracker.md`,
+      stages: loopDef.stages,
+      completion: loopDef.completion,
+      multi_agent: loopDef.multi_agent || false,
+      model: loopDef.model || "claude-sonnet-4-6",
+      cadence: loopDef.cadence ?? 0
+    };
+    if (loopDef.data_files && loopDef.data_files.length > 0) {
+      loopConfig.data_files = loopDef.data_files.map((f) => `${loopDirName}/${f}`);
+    }
+    if (loopDef.directories && loopDef.directories.length > 0) {
+      loopConfig.directories = loopDef.directories.map((d) => `${loopDirName}/${d}`);
+    }
+    if (loopDef.entities && loopDef.entities.length > 0) {
+      loopConfig.entities = loopDef.entities;
+    }
+    if (loopDef.feeds) loopConfig.feeds = loopDef.feeds;
+    if (loopDef.fed_by) loopConfig.fed_by = loopDef.fed_by;
+    if (loopDef.multi_agent && typeof loopDef.multi_agent === "object" && loopDef.multi_agent.enabled) {
+      loopConfig.lock = {
+        file: `${loopDirName}/.tracker-lock`,
+        type: "echo",
+        stale_seconds: 60
+      };
+      loopConfig.worktree = {
+        strategy: "shared",
+        auto_merge: true
+      };
+    }
+    loops[loopKey] = loopConfig;
+  });
+  mkdirSync(customDir, { recursive: true });
+  const loopsDir = join(customDir, "loops");
+  mkdirSync(loopsDir, { recursive: true });
+  writeFileSync(join(customDir, "ralphflow.yaml"), stringifyYaml(config, { lineWidth: 0 }), "utf-8");
+  definition.loops.forEach((loopDef, index) => {
+    const baseKey = loopDef.name.toLowerCase().replace(/\s+/g, "-");
+    const loopKey = baseKey.endsWith("-loop") ? baseKey : `${baseKey}-loop`;
+    const dirPrefix = String(index).padStart(2, "0");
+    const loopDirName = `${dirPrefix}-${loopKey}`;
+    const loopDir = join(loopsDir, loopDirName);
+    mkdirSync(loopDir, { recursive: true });
+    writeFileSync(join(loopDir, "prompt.md"), `# ${loopDef.name} \u2014 Prompt
+
+<!-- Add your prompt here -->
+`, "utf-8");
+    writeFileSync(join(loopDir, "tracker.md"), `# ${loopDef.name} \u2014 Tracker
+
+- stage: ${loopDef.stages[0] || "init"}
+`, "utf-8");
+    if (loopDef.data_files) {
+      for (const dataFile of loopDef.data_files) {
+        writeFileSync(join(loopDir, dataFile), `# ${dataFile}
+
+<!-- Add content here -->
+`, "utf-8");
+      }
+    }
+    if (loopDef.directories) {
+      for (const dir of loopDef.directories) {
+        const dirPath = join(loopDir, dir);
+        mkdirSync(dirPath, { recursive: true });
+        writeFileSync(join(dirPath, ".gitkeep"), "", "utf-8");
+      }
+    }
+  });
+}
+function deleteCustomTemplate(cwd, name) {
+  if (BUILT_IN_TEMPLATES.includes(name)) {
+    throw new Error("Cannot delete built-in templates");
+  }
+  const validation = validateTemplateName(name);
+  if (!validation.valid) {
+    throw new Error(validation.error);
+  }
+  const customDir = join(cwd, ".ralph-flow", ".templates", name);
+  if (!existsSync(customDir)) {
+    throw new Error(`Template "${name}" not found`);
+  }
+  rmSync(customDir, { recursive: true, force: true });
+}
+
+// src/core/config.ts
+import { readFileSync as readFileSync2, existsSync as existsSync2, readdirSync as readdirSync2 } from "fs";
+import { join as join2 } from "path";
+import { parse as parseYaml } from "yaml";
+var LOOP_ALIASES = {
+  // code-implementation aliases
+  story: "story-loop",
+  stories: "story-loop",
+  tasks: "tasks-loop",
+  task: "tasks-loop",
+  delivery: "delivery-loop",
+  deliver: "delivery-loop",
+  // research aliases
+  discovery: "discovery-loop",
+  discover: "discovery-loop",
+  research: "research-loop",
+  document: "document-loop",
+  doc: "document-loop"
+};
+function listFlows(cwd) {
+  const baseDir = join2(cwd, ".ralph-flow");
+  if (!existsSync2(baseDir)) return [];
+  return readdirSync2(baseDir, { withFileTypes: true }).filter((d) => d.isDirectory() && !d.name.startsWith(".")).filter((d) => existsSync2(join2(baseDir, d.name, "ralphflow.yaml"))).map((d) => d.name);
+}
+function resolveFlowDir(cwd, flowName) {
+  const baseDir = join2(cwd, ".ralph-flow");
+  if (!existsSync2(baseDir)) {
+    throw new Error("No .ralph-flow/ found. Run `npx ralphflow init` first.");
+  }
+  const flows = listFlows(cwd);
+  if (flows.length === 0) {
+    throw new Error("No flows found in .ralph-flow/. Run `npx ralphflow init` first.");
+  }
+  if (flowName) {
+    if (!flows.includes(flowName)) {
+      throw new Error(`Flow "${flowName}" not found. Available: ${flows.join(", ")}`);
+    }
+    return join2(baseDir, flowName);
+  }
+  if (flows.length === 1) {
+    return join2(baseDir, flows[0]);
+  }
+  throw new Error(
+    `Multiple flows found: ${flows.join(", ")}. Use --flow <name> to specify which one.`
+  );
+}
+function loadConfig(flowDir) {
+  const configPath = join2(flowDir, "ralphflow.yaml");
+  if (!existsSync2(configPath)) {
+    throw new Error(`No ralphflow.yaml found in ${flowDir}`);
+  }
+  const raw = readFileSync2(configPath, "utf-8");
+  const config = parseYaml(raw);
+  if (!config.name) {
+    throw new Error('ralphflow.yaml: missing required field "name"');
+  }
+  if (!config.loops || Object.keys(config.loops).length === 0) {
+    throw new Error('ralphflow.yaml: missing required field "loops"');
+  }
+  if (!config.dir) {
+    config.dir = ".ralph-flow";
+  }
+  return config;
+}
+function resolveLoop(config, name) {
+  if (config.loops[name]) {
+    return { key: name, loop: config.loops[name] };
+  }
+  const aliased = LOOP_ALIASES[name.toLowerCase()];
+  if (aliased && config.loops[aliased]) {
+    return { key: aliased, loop: config.loops[aliased] };
+  }
+  for (const [key, loop] of Object.entries(config.loops)) {
+    if (key.startsWith(name) || loop.name.toLowerCase().includes(name.toLowerCase())) {
+      return { key, loop };
+    }
+  }
+  const available = Object.keys(config.loops).join(", ");
+  throw new Error(`Unknown loop "${name}". Available: ${available}`);
+}
+
+// src/core/db.ts
+import Database from "better-sqlite3";
+import { join as join3 } from "path";
+import { existsSync as existsSync3, mkdirSync as mkdirSync2 } from "fs";
+var SCHEMA = `
+CREATE TABLE IF NOT EXISTS loop_state (
+  flow_name TEXT NOT NULL,
+  loop_key TEXT NOT NULL,
+  status TEXT NOT NULL DEFAULT 'pending',
+  iterations_run INTEGER NOT NULL DEFAULT 0,
+  completed_at TEXT,
+  PRIMARY KEY (flow_name, loop_key)
+);
+`;
+var _db = null;
+function getDb(cwd) {
+  if (_db) return _db;
+  const dir = join3(cwd, ".ralph-flow");
+  if (!existsSync3(dir)) mkdirSync2(dir, { recursive: true });
+  _db = new Database(join3(dir, ".ralphflow.db"));
+  _db.pragma("journal_mode = WAL");
+  _db.exec(SCHEMA);
+  return _db;
+}
+function getLoopStatus(db, flow, loopKey) {
+  const row = db.prepare("SELECT status FROM loop_state WHERE flow_name = ? AND loop_key = ?").get(flow, loopKey);
+  return row ? row.status : "pending";
+}
+function isLoopComplete(db, flow, loopKey) {
+  return getLoopStatus(db, flow, loopKey) === "complete";
+}
+function markLoopRunning(db, flow, loopKey) {
+  db.prepare(`
+    INSERT INTO loop_state (flow_name, loop_key, status, iterations_run)
+    VALUES (?, ?, 'running', 0)
+    ON CONFLICT(flow_name, loop_key) DO UPDATE SET status = 'running'
+  `).run(flow, loopKey);
+}
+function incrementIteration(db, flow, loopKey) {
+  db.prepare(`
+    UPDATE loop_state SET iterations_run = iterations_run + 1
+    WHERE flow_name = ? AND loop_key = ?
+  `).run(flow, loopKey);
+}
+function markLoopComplete(db, flow, loopKey) {
+  db.prepare(`
+    UPDATE loop_state SET status = 'complete', completed_at = datetime('now')
+    WHERE flow_name = ? AND loop_key = ?
+  `).run(flow, loopKey);
+}
+function resetLoopState(db, flow, loopKey) {
+  db.prepare("DELETE FROM loop_state WHERE flow_name = ? AND loop_key = ?").run(flow, loopKey);
+}
+function deleteFlowState(db, flow) {
+  db.prepare("DELETE FROM loop_state WHERE flow_name = ?").run(flow);
+}
+function getAllLoopStates(db, flow) {
+  return db.prepare("SELECT * FROM loop_state WHERE flow_name = ?").all(flow);
+}
+
+// src/core/status.ts
+import { readFileSync as readFileSync3, existsSync as existsSync4 } from "fs";
+import { join as join4 } from "path";
+import chalk from "chalk";
+import Table from "cli-table3";
+async function showStatus(cwd, flowName) {
+  const flows = flowName ? [flowName] : listFlows(cwd);
+  if (flows.length === 0) {
+    console.log();
+    console.log(chalk.yellow("  No flows found. Run `npx ralphflow init` first."));
+    console.log();
+    return;
+  }
+  for (const flow of flows) {
+    const flowDir = resolveFlowDir(cwd, flow);
+    const config = loadConfig(flowDir);
+    console.log();
+    console.log(chalk.bold(`  RalphFlow \u2014 ${flow}`));
+    console.log();
+    const table = new Table({
+      chars: {
+        top: "",
+        "top-mid": "",
+        "top-left": "",
+        "top-right": "",
+        bottom: "",
+        "bottom-mid": "",
+        "bottom-left": "",
+        "bottom-right": "",
+        left: "  ",
+        "left-mid": "",
+        mid: "",
+        "mid-mid": "",
+        right: "",
+        "right-mid": "",
+        middle: "  "
+      },
+      style: { "padding-left": 0, "padding-right": 1 },
+      head: [
+        chalk.dim("Loop"),
+        chalk.dim("Stage"),
+        chalk.dim("Active"),
+        chalk.dim("Progress")
+      ]
+    });
+    const sortedLoops = Object.entries(config.loops).sort(([, a], [, b]) => a.order - b.order);
+    for (const [key, loop] of sortedLoops) {
+      const status = parseTracker(loop.tracker, flowDir, loop.name);
+      table.push([
+        loop.name,
+        status.stage,
+        status.active,
+        `${status.completed}/${status.total}`
+      ]);
+      if (status.agents && status.agents.length > 0) {
+        for (const agent of status.agents) {
+          table.push([
+            chalk.dim(`  ${agent.name}`),
+            chalk.dim(agent.stage),
+            chalk.dim(agent.activeTask),
+            chalk.dim(agent.lastHeartbeat)
+          ]);
+        }
+      }
+    }
+    console.log(table.toString());
+  }
+  console.log();
+}
+function parseTracker(trackerPath, flowDir, loopName) {
+  const fullPath = join4(flowDir, trackerPath);
+  const status = {
+    loop: loopName,
+    stage: "\u2014",
+    active: "none",
+    completed: 0,
+    total: 0
+  };
+  if (!existsSync4(fullPath)) {
+    return status;
+  }
+  const content = readFileSync3(fullPath, "utf-8");
+  const lines = content.split("\n");
+  for (const line of lines) {
+    const metaMatch = line.match(/^- (\w[\w_]*): (.+)$/);
+    if (metaMatch) {
+      const [, key, value] = metaMatch;
+      if (key === "stage") status.stage = value.trim();
+      if (key === "active_story" || key === "active_task") status.active = value.trim();
+      if (key === "completed_stories" || key === "completed_tasks") {
+        const arrayMatch = value.match(/\[(.+)\]/);
+        if (arrayMatch) {
+          status.completed = arrayMatch[1].split(",").filter((s) => s.trim()).length;
+        }
+      }
+    }
+  }
+  const unchecked = (content.match(/- \[ \]/g) || []).length;
+  const checked = (content.match(/- \[x\]/gi) || []).length;
+  if (unchecked + checked > 0) {
+    status.total = unchecked + checked;
+    status.completed = checked;
+  }
+  const agentTableMatch = content.match(/\| agent \|.*\n\|[-|]+\n((?:\|.*\n)*)/);
+  if (agentTableMatch) {
+    const agentRows = agentTableMatch[1].trim().split("\n");
+    status.agents = [];
+    for (const row of agentRows) {
+      const cells = row.split("|").map((s) => s.trim()).filter(Boolean);
+      if (cells.length >= 4) {
+        status.agents.push({
+          name: cells[0],
+          activeTask: cells[1],
+          stage: cells[2],
+          lastHeartbeat: cells[3]
+        });
+      }
+    }
+    if (status.agents.length === 0) {
+      status.agents = void 0;
+    }
+  }
+  return status;
+}
+
+export {
+  BUILT_IN_TEMPLATES,
+  resolveTemplatePathWithCustom,
+  copyTemplate,
+  validateTemplateName,
+  listCustomTemplates,
+  getAvailableTemplates,
+  createCustomTemplate,
+  deleteCustomTemplate,
+  listFlows,
+  resolveFlowDir,
+  loadConfig,
+  resolveLoop,
+  getDb,
+  isLoopComplete,
+  markLoopRunning,
+  incrementIteration,
+  markLoopComplete,
+  resetLoopState,
+  deleteFlowState,
+  getAllLoopStates,
+  showStatus,
+  parseTracker
+};