@neriros/ralphy 2.4.0 → 2.5.0

package/dist/cli/index.js

@@ -35498,9 +35498,8 @@ var require_cjs = __commonJS((exports, module) => {
 });
 
 // apps/cli/src/index.ts
-import { resolve, join as join11 } from "path";
-import { existsSync as existsSync6, mkdirSync as mkdirSync3 } from "fs";
-import { spawnSync as spawnSync2 } from "child_process";
+import { resolve, join as join11, dirname as dirname3 } from "path";
+import { exists, mkdir as mkdir2 } from "fs/promises";
 
 // node_modules/.bun/ink@5.2.1+1f88f629f0141b18/node_modules/ink/build/render.js
 import { Stream } from "stream";
@@ -41044,9 +41043,6 @@ var import_react21 = __toESM(require_react(), 1);
 // apps/cli/src/index.ts
 var import_react58 = __toESM(require_react(), 1);
 
-// apps/cli/src/cli.ts
-import { readFileSync as readFileSync2 } from "fs";
-
 // packages/output/src/output.ts
 var formatters = {
   bold: (text) => source_default.bold(text),
@@ -41111,7 +41107,7 @@ var HELP_TEXT = [
 function printHelp() {
   log(HELP_TEXT);
 }
-function parseArgs(argv) {
+async function parseArgs(argv) {
   const result2 = {
     mode: "task",
     name: "",
@@ -41150,7 +41146,7 @@ function parseArgs(argv) {
     }
     if (expectModelFlag) {
       if (!VALID_MODELS.has(arg)) {
-        throw new Error(`Invalid model '${arg}'. Valid models: ${[...VALID_MODELS].join(", ")}`);
+        throw new Error("Invalid model");
       }
       result2.model = arg;
       expectModelFlag = false;
@@ -41167,7 +41163,7 @@ function parseArgs(argv) {
       continue;
     }
     if (expectPromptFile) {
-      result2.prompt = readFileSync2(arg, "utf-8");
+      result2.prompt = await Bun.file(arg).text();
       expectPromptFile = false;
       continue;
     }
@@ -41270,9 +41266,7 @@ function parseArgs(argv) {
         if (VALID_MODES.has(arg)) {
           result2.mode = arg;
         } else {
-          throw new Error(`Unknown argument '${arg}'
-
-Run 'ralph --help' for usage information.`);
+          throw new Error("Unknown argument. Run 'ralph --help' for usage information.");
         }
         break;
     }
@@ -41283,7 +41277,7 @@ Run 'ralph --help' for usage information.`);
 // packages/context/src/context.ts
 import { AsyncLocalStorage } from "async_hooks";
 import {
-  readFileSync as readFileSync3,
+  readFileSync as readFileSync2,
   writeFileSync,
   existsSync as existsSync2,
   unlinkSync,
@@ -41296,7 +41290,7 @@ class FileSystemProvider {
   read(path) {
     if (!existsSync2(path))
       return null;
-    return readFileSync3(path, "utf-8");
+    return readFileSync2(path, "utf-8");
   }
   write(path, content) {
     mkdirSync(dirname(path), { recursive: true });
@@ -41336,11 +41330,9 @@ function createDefaultContext() {
 // apps/cli/src/components/App.tsx
 var import_react57 = __toESM(require_react(), 1);
 import { join as join10 } from "path";
-import { existsSync as existsSync5, mkdirSync as mkdirSync2 } from "fs";
 
 // packages/core/src/state.ts
 import { join as join2 } from "path";
-import { execSync } from "child_process";
 
 // node_modules/.bun/zod@3.25.76/node_modules/zod/v3/external.js
 var exports_external = {};
@@ -45394,7 +45386,7 @@ function readState(changeDir) {
   const filePath = join2(changeDir, STATE_FILE);
   const raw = getStorage().read(filePath);
   if (raw === null)
-    throw new Error(`.ralph-state.json not found in ${changeDir}`);
+    throw new Error(".ralph-state.json not found");
   return StateSchema.parse(JSON.parse(raw));
 }
 function writeState(changeDir, state) {
@@ -45412,7 +45404,16 @@ function buildInitialState(options) {
   const now2 = new Date().toISOString();
   let branch = "main";
   try {
-    branch = execSync("git branch --show-current", { encoding: "utf-8" }).trim();
+    const proc = Bun.spawnSync({
+      cmd: ["git", "branch", "--show-current"],
+      stdout: "pipe",
+      stderr: "pipe"
+    });
+    if (proc.exitCode === 0) {
+      const out = new TextDecoder().decode(proc.stdout).trim();
+      if (out)
+        branch = out;
+    }
   } catch {}
   return StateSchema.parse({
     version: "2",
@@ -49316,7 +49317,7 @@ var {spawn: bunSpawn } = globalThis.Bun;
 var spawn = bunSpawn;
 
 // packages/engine/src/engine.ts
-import { writeFileSync as writeFileSync2, unlinkSync as unlinkSync2, existsSync as existsSync3, mkdtempSync } from "fs";
+import { mkdtemp, unlink } from "fs/promises";
 import { join as join5 } from "path";
 import { tmpdir } from "os";
 
@@ -50049,8 +50050,8 @@ function buildCodexArgs() {
   return ["exec", "--json", "--color", "never", "--dangerously-bypass-approvals-and-sandbox", "-"];
 }
 async function runInteractive(model, prompt, taskDir) {
-  const promptFile = taskDir ? join5(taskDir, "_interactive_prompt.md") : join5(mkdtempSync(join5(tmpdir(), "ralph-")), "prompt.md");
-  writeFileSync2(promptFile, prompt);
+  const promptFile = taskDir ? join5(taskDir, "_interactive_prompt.md") : join5(await mkdtemp(join5(tmpdir(), "ralph-")), "prompt.md");
+  await Bun.write(promptFile, prompt);
   try {
     const cmd = [
       "claude",
@@ -50076,13 +50077,13 @@ async function runInteractive(model, prompt, taskDir) {
     });
     const exitCode = await proc.exited;
     const doneFile = taskDir ? join5(taskDir, "_interactive_done") : null;
-    if (doneFile && existsSync3(doneFile)) {
+    if (doneFile && await Bun.file(doneFile).exists()) {
       return { exitCode: 0, usage: null, sessionId: null, rateLimited: false };
     }
     return { exitCode, usage: null, sessionId: null, rateLimited: false };
   } finally {
     try {
-      unlinkSync2(promptFile);
+      await unlink(promptFile);
     } catch {}
   }
 }
@@ -50218,37 +50219,44 @@ function isRateLimitText(text) {
 }
 
 // packages/core/src/git.ts
-import { execSync as execSync2 } from "child_process";
+function runGit(args) {
+  const proc = Bun.spawnSync({
+    cmd: ["git", ...args],
+    stdout: "pipe",
+    stderr: "pipe"
+  });
+  const decoder = new TextDecoder;
+  return {
+    exitCode: proc.exitCode,
+    stdout: proc.stdout ? decoder.decode(proc.stdout) : "",
+    stderr: proc.stderr ? decoder.decode(proc.stderr) : ""
+  };
+}
 function getCurrentBranch() {
-  try {
-    return execSync2("git branch --show-current", { encoding: "utf-8" }).trim();
-  } catch {
+  const result2 = runGit(["branch", "--show-current"]);
+  if (result2.exitCode !== 0)
     return "main";
-  }
+  return result2.stdout.trim() || "main";
 }
 function gitAdd(files) {
-  execSync2(`git add ${files.map((f) => `"${f}"`).join(" ")}`, {
-    stdio: "pipe"
-  });
+  const result2 = runGit(["add", ...files]);
+  if (result2.exitCode !== 0) {
+    throw new Error("git add failed", { cause: { stderr: result2.stderr.trim() } });
+  }
 }
 function gitCommit(message) {
-  execSync2(`git commit -m "${message.replace(/"/g, "\\\"")}"`, {
-    stdio: "pipe"
-  });
+  const result2 = runGit(["commit", "-m", message]);
+  if (result2.exitCode !== 0) {
+    throw new Error("git commit failed", { cause: { stderr: result2.stderr.trim() } });
+  }
 }
 function gitPush() {
   const branch = getCurrentBranch();
-  try {
-    execSync2("git push", { stdio: "pipe" });
-  } catch {
-    try {
-      execSync2(`git push -u origin ${branch}`, { stdio: "pipe" });
-    } catch {
-      try {
-        execSync2(`git push --set-upstream origin ${branch}`, { stdio: "pipe" });
-      } catch {}
-    }
-  }
+  if (runGit(["push"]).exitCode === 0)
+    return;
+  if (runGit(["push", "-u", "origin", branch]).exitCode === 0)
+    return;
+  runGit(["push", "--set-upstream", "origin", branch]);
 }
 function commitTaskDir(taskDir, message) {
   try {
@@ -50815,106 +50823,121 @@ function TaskLoop({ opts }) {
 }
 
 // packages/openspec/src/openspec-change-store.ts
-import { join as join9 } from "path";
-import { readFileSync as readFileSync4, writeFileSync as writeFileSync3, readdirSync as readdirSync2, existsSync as existsSync4 } from "fs";
-import { spawnSync } from "child_process";
+import { join as join9, dirname as dirname2 } from "path";
+import { readdir, mkdir } from "fs/promises";
+function resolveOpenspecBin() {
+  const pkgJsonPath = Bun.resolveSync("@fission-ai/openspec/package.json", import.meta.dir);
+  return join9(dirname2(pkgJsonPath), "bin", "openspec.js");
+}
+function runOpenspec(args, options = {}) {
+  const stdio = options.inherit ? ["inherit", "inherit", "inherit"] : ["ignore", "pipe", "pipe"];
+  const proc = Bun.spawnSync({
+    cmd: [process.execPath, resolveOpenspecBin(), ...args],
+    stdio
+  });
+  const decoder = new TextDecoder;
+  return {
+    status: proc.exitCode,
+    stdout: proc.stdout ? decoder.decode(proc.stdout) : "",
+    stderr: proc.stderr ? decoder.decode(proc.stderr) : ""
+  };
+}
 
 class OpenSpecChangeStore {
-  createChange(name, description) {
-    const result2 = spawnSync("bunx", ["openspec", "new", "change", name, "--description", description], { stdio: "inherit", encoding: "utf-8" });
+  async createChange(name, description) {
+    const result2 = runOpenspec(["new", "change", name, "--description", description], {
+      inherit: true
+    });
     if (result2.status !== 0) {
-      throw new Error(`openspec new change failed with exit code ${result2.status ?? "unknown"}`);
+      throw new Error("openspec new change failed");
     }
-    return Promise.resolve();
   }
   getChangeDirectory(name) {
     return join9("openspec", "changes", name);
   }
-  listChanges() {
-    const result2 = spawnSync("bunx", ["openspec", "list", "--json"], { encoding: "utf-8" });
+  async listChanges() {
+    const result2 = runOpenspec(["list", "--json"]);
     if (result2.stdout) {
       try {
         const parsed = JSON.parse(result2.stdout);
-        if (Array.isArray(parsed)) {
-          return Promise.resolve(parsed.map((item) => String(item)));
-        }
+        if (Array.isArray(parsed))
+          return parsed.map((item) => String(item));
         if (parsed && typeof parsed === "object" && "changes" in parsed && parsed.changes) {
-          return Promise.resolve(parsed.changes.map((change) => change.name));
+          return parsed.changes.map((change) => change.name);
         }
       } catch {}
     }
     const changesDir = join9("openspec", "changes");
-    if (!existsSync4(changesDir))
-      return Promise.resolve([]);
-    const names = readdirSync2(changesDir, { withFileTypes: true }).filter((entry) => entry.isDirectory()).map((entry) => entry.name);
-    return Promise.resolve(names);
+    if (!await Bun.file(changesDir).exists())
+      return [];
+    try {
+      const entries = await readdir(changesDir, { withFileTypes: true });
+      return entries.filter((entry) => entry.isDirectory() && entry.name !== "archive").map((entry) => entry.name);
+    } catch {
+      return [];
+    }
   }
-  readTaskList(name) {
-    const path = join9("openspec", "changes", name, "tasks.md");
-    if (!existsSync4(path))
-      return Promise.resolve("");
-    return Promise.resolve(readFileSync4(path, "utf-8"));
+  async readTaskList(name) {
+    const file = Bun.file(join9("openspec", "changes", name, "tasks.md"));
+    if (!await file.exists())
+      return "";
+    return await file.text();
   }
-  writeTaskList(name, content) {
+  async writeTaskList(name, content) {
     const path = join9("openspec", "changes", name, "tasks.md");
-    writeFileSync3(path, content, "utf-8");
-    return Promise.resolve();
+    await mkdir(dirname2(path), { recursive: true });
+    await Bun.write(path, content);
   }
-  appendSteering(name, message) {
+  async appendSteering(name, message) {
     const path = join9("openspec", "changes", name, "steering.md");
-    const existing = existsSync4(path) ? readFileSync4(path, "utf-8") : null;
+    const file = Bun.file(path);
+    const existing = await file.exists() ? await file.text() : null;
     const updated = existing ? `${message}
 
 ${existing.trimStart()}` : `${message}
 `;
-    writeFileSync3(path, updated, "utf-8");
-    return Promise.resolve();
-  }
-  readSection(name, artifact, heading) {
-    const path = join9("openspec", "changes", name, artifact);
-    if (!existsSync4(path))
-      return Promise.resolve("");
-    const content = readFileSync4(path, "utf-8");
+    await mkdir(dirname2(path), { recursive: true });
+    await Bun.write(path, updated);
+  }
+  async readSection(name, artifact, heading) {
+    const file = Bun.file(join9("openspec", "changes", name, artifact));
+    if (!await file.exists())
+      return "";
+    const content = await file.text();
     const headingIndex = content.indexOf(heading);
     if (headingIndex === -1)
-      return Promise.resolve("");
+      return "";
     const afterHeading = content.slice(headingIndex + heading.length);
     const levelMatch = heading.match(/^(#+)/);
     const level = levelMatch ? levelMatch[1].length : 2;
     const nextHeadingPattern = new RegExp(`\\n#{1,${level}} `);
     const nextMatch = afterHeading.match(nextHeadingPattern);
     const sectionContent = nextMatch ? afterHeading.slice(0, nextMatch.index) : afterHeading;
-    return Promise.resolve(sectionContent.trim());
+    return sectionContent.trim();
   }
-  validateChange(name) {
-    const result2 = spawnSync("bunx", ["openspec", "validate", name, "--json", "--no-interactive"], {
-      encoding: "utf-8"
-    });
+  async validateChange(name) {
+    const result2 = runOpenspec(["validate", name, "--json", "--no-interactive"]);
     if (result2.stdout) {
       try {
         const parsed = JSON.parse(result2.stdout);
-        return Promise.resolve({
+        return {
           valid: parsed.valid ?? result2.status === 0,
           warnings: parsed.warnings ?? [],
           errors: parsed.errors ?? []
-        });
+        };
       } catch {}
     }
-    return Promise.resolve({
+    return {
       valid: result2.status === 0,
       warnings: [],
       errors: result2.stderr ? [result2.stderr] : []
-    });
+    };
   }
-  archiveChange(name) {
-    const result2 = spawnSync("bunx", ["openspec", "archive", name, "-y", "--skip-specs"], {
-      stdio: "inherit",
-      encoding: "utf-8"
-    });
+  async archiveChange(name) {
+    const result2 = runOpenspec(["archive", name, "-y", "--skip-specs"], { inherit: true });
     if (result2.status !== 0) {
-      throw new Error(`openspec archive failed with exit code ${result2.status ?? "unknown"}`);
+      throw new Error("openspec archive failed");
     }
-    return Promise.resolve();
   }
 }
 // apps/cli/src/components/App.tsx
@@ -50952,7 +50975,7 @@ function App2({ args, statesDir, tasksDir }) {
         }, undefined, false, undefined, this);
       }
       const stateDir = join10(statesDir, args.name);
-      if (!existsSync5(join10(stateDir, ".ralph-state.json"))) {
+      if (getStorage().read(join10(stateDir, ".ralph-state.json")) === null) {
         return /* @__PURE__ */ jsx_dev_runtime9.jsxDEV(ErrorMessage, {
           message: `Error: change '${args.name}' not found`
         }, undefined, false, undefined, this);
@@ -50978,8 +51001,6 @@ function App2({ args, statesDir, tasksDir }) {
           message: "Error: --name is required for task mode"
         }, undefined, false, undefined, this);
       }
-      mkdirSync2(join10(statesDir, args.name), { recursive: true });
-      mkdirSync2(join10(tasksDir, args.name), { recursive: true });
       return /* @__PURE__ */ jsx_dev_runtime9.jsxDEV(TaskLoop, {
         opts: {
           name: args.name,
@@ -51003,27 +51024,38 @@ function App2({ args, statesDir, tasksDir }) {
 }
 
 // apps/cli/src/index.ts
-function findProjectRoot() {
+if (typeof globalThis.Bun === "undefined") {
+  process.stderr.write(`ralph requires the Bun runtime (https://bun.sh/). It is not compatible with plain Node.js.
+` + "Install Bun and re-run with `bun` or `bunx ralphy`.\n");
+  process.exit(1);
+}
+async function findProjectRoot() {
   let dir = process.cwd();
   while (dir !== "/") {
-    if (existsSync6(join11(dir, "openspec")))
+    if (await exists(join11(dir, "openspec")))
       return dir;
     dir = resolve(dir, "..");
   }
   return process.cwd();
 }
 try {
-  const args = parseArgs(process.argv.slice(2));
-  const projectRoot = findProjectRoot();
+  const args = await parseArgs(process.argv.slice(2));
+  const projectRoot = await findProjectRoot();
   const statesDir = join11(projectRoot, ".ralph", "tasks");
   const tasksDir = join11(projectRoot, "openspec", "changes");
   if (args.mode === "init") {
-    mkdirSync3(statesDir, { recursive: true });
-    spawnSync2("bunx", ["openspec", "init", "--tools", "none", "--force"], {
-      stdio: "inherit",
+    await mkdir2(statesDir, { recursive: true });
+    const openspecBin = join11(dirname3(Bun.resolveSync("@fission-ai/openspec/package.json", import.meta.dir)), "bin", "openspec.js");
+    Bun.spawnSync({
+      cmd: [process.execPath, openspecBin, "init", "--tools", "none", "--force"],
+      stdio: ["inherit", "inherit", "inherit"],
       cwd: process.cwd()
     });
   }
+  if (args.mode === "task" && args.name) {
+    await mkdir2(join11(statesDir, args.name), { recursive: true });
+    await mkdir2(join11(tasksDir, args.name), { recursive: true });
+  }
   runWithContext(createDefaultContext(), () => {
     render_default(import_react58.createElement(App2, { args, statesDir, tasksDir }));
   });