@neriros/ralphy 2.9.1 → 2.9.3

package/README.md

@@ -1,5 +1,12 @@
 # Ralphy
 
+[![npm version](https://img.shields.io/npm/v/@neriros/ralphy.svg)](https://www.npmjs.com/package/@neriros/ralphy)
+[![npm downloads](https://img.shields.io/npm/dm/@neriros/ralphy.svg)](https://www.npmjs.com/package/@neriros/ralphy)
+[![license](https://img.shields.io/npm/l/@neriros/ralphy.svg)](https://github.com/NeriRos/ralphy/blob/main/LICENSE)
+[![GitHub stars](https://img.shields.io/github/stars/NeriRos/ralphy.svg?style=social)](https://github.com/NeriRos/ralphy)
+[![GitHub issues](https://img.shields.io/github/issues/NeriRos/ralphy.svg)](https://github.com/NeriRos/ralphy/issues)
+[![Bun](https://img.shields.io/badge/runtime-Bun-fbf0df.svg)](https://bun.sh)
+
 An iterative AI task execution framework. Ralphy orchestrates multi-phase autonomous work using Claude or Codex engines, with built-in state management, progress tracking, and cost safeguards.
 
 ## How It Works
@@ -19,9 +26,9 @@ Each iteration reads the `## Steering` section of `proposal.md`, picks the first
 ### npm (global)
 
 ```bash
-npm install -g ralphy
+npm install -g @neriros/ralphy
 # or
-bunx ralphy
+bunx @neriros/ralphy
 ```
 
 Requires [Bun](https://bun.sh) as the runtime.

package/dist/cli/index.js

@@ -56407,7 +56407,7 @@ function log(msg) {
 // package.json
 var package_default = {
   name: "@neriros/ralphy",
-  version: "2.9.1",
+  version: "2.9.3",
   description: "An iterative AI task execution framework. Orchestrates multi-phase autonomous work using Claude or Codex engines.",
   keywords: [
     "agent",
@@ -70606,6 +70606,42 @@ async function createWorktree(projectRoot, changeName, runner) {
 async function removeWorktree(projectRoot, cwd2, runner) {
   await runner.run(["worktree", "remove", "--force", cwd2], projectRoot);
 }
+async function isWorktreeSafeToRemove(cwd2, base2, runner) {
+  const status = await runner.run(["status", "--porcelain"], cwd2);
+  const dirty = status.stdout.trim();
+  let unpushedCommits = "";
+  try {
+    const log2 = await runner.run(["log", "--oneline", `${base2}..HEAD`, "--no-merges"], cwd2);
+    unpushedCommits = log2.stdout.trim();
+  } catch {
+    unpushedCommits = "<unknown: failed to compare against base>";
+  }
+  if (dirty && unpushedCommits) {
+    return {
+      safe: false,
+      reason: "uncommitted changes AND unpushed commits present",
+      dirty,
+      unpushedCommits
+    };
+  }
+  if (dirty) {
+    return {
+      safe: false,
+      reason: "uncommitted or untracked files present",
+      dirty,
+      unpushedCommits
+    };
+  }
+  if (unpushedCommits) {
+    return {
+      safe: false,
+      reason: `commits ahead of ${base2} were not pushed/PR'd`,
+      dirty,
+      unpushedCommits
+    };
+  }
+  return { safe: true, dirty, unpushedCommits };
+}
 
 // apps/cli/src/agent/pr.ts
 function defaultTitle(issue) {
@@ -70770,6 +70806,23 @@ function nextId() {
   return `${Date.now()}-${lineCounter}`;
 }
 var SPINNER_FRAMES = ["\u280B", "\u2819", "\u2839", "\u2838", "\u283C", "\u2834", "\u2826", "\u2827", "\u2807", "\u280F"];
+async function appendSteering(proposalPath, steering) {
+  const file = Bun.file(proposalPath);
+  const prev = await file.exists() ? await file.text() : "";
+  const stamped = `
+
+### Steering feedback (${new Date().toISOString()})
+
+${steering}
+`;
+  const next = prev.includes("## Steering") ? prev.replace(/## Steering\n+([\s\S]*?)$/, (_m, rest2) => `## Steering
+${stamped}
+${rest2}`) : prev + `
+## Steering
+${stamped}
+`;
+  await Bun.write(proposalPath, next);
+}
 function fmtElapsed(ms) {
   const s = Math.floor(ms / 1000);
   if (s < 60)
@@ -70952,78 +71005,178 @@ function AgentMode({ args, projectRoot, statesDir, tasksDir }) {
                 appendLog(`! createPr requested but no worktree branch is tracked for ${changeName} (use --worktree)`, "yellow");
                 effectiveCode = PR_FAILED_EXIT;
               } else {
-                try {
-                  const pr = await createPullRequest({ cwd: cwd2, branch, issue: prIssue, base: cfg.prBaseBranch }, bunCmdRunner);
-                  if (!pr) {
-                    appendLog(`  no commits ahead of ${cfg.prBaseBranch} \u2014 skipping PR`, "gray");
-                  } else {
-                    appendLog(`  ${pr.created ? "opened" : "found existing"} PR: ${pr.url}`, "green");
-                    const wantFixCi = args.fixCi || cfg.fixCiOnFailure;
-                    if (wantFixCi) {
-                      appendLog(`  watching CI for ${pr.url} (max ${cfg.maxCiFixAttempts} fix attempts)`, "gray");
-                      const proposalPath = join14(statesDirByChange.get(changeName) ?? statesDir, "..", "..", "openspec", "changes", changeName, "proposal.md");
-                      const result2 = await fixCiUntilGreen({
-                        getStatus: () => getPrChecksStatus(pr.url, bunCmdRunner, cwd2),
-                        getFailedLogs: (ids) => fetchFailedRunLogs(ids, bunCmdRunner, cwd2),
-                        runTaskWithSteering: async (steering) => {
-                          try {
-                            const file = Bun.file(proposalPath);
-                            const prev = await file.exists() ? await file.text() : "";
-                            const stamped = `
-
-### CI feedback (${new Date().toISOString()})
+                const proposalPath = join14(statesDirByChange.get(changeName) ?? statesDir, "..", "..", "openspec", "changes", changeName, "proposal.md");
+                const maxHookFixAttempts = cfg.maxCiFixAttempts;
+                const runWorkerWithSteering = async (steering) => {
+                  try {
+                    await appendSteering(proposalPath, steering);
+                  } catch (steerErr) {
+                    appendLog(`! could not append steering: ${steerErr.message}`, "red");
+                    return 1;
+                  }
+                  const rp = Bun.spawn({
+                    cmd: buildTaskCmd(),
+                    cwd: cwd2,
+                    stdout: "ignore",
+                    stderr: "ignore",
+                    stdin: "ignore"
+                  });
+                  return rp.exited;
+                };
+                let commitFixAttempt = 0;
+                let commitGaveUp = false;
+                while (true) {
+                  let dirty = "";
+                  try {
+                    const status = await bunCmdRunner.run(["git", "status", "--porcelain"], cwd2);
+                    dirty = status.stdout.trim();
+                  } catch (err) {
+                    appendLog(`! git status failed for ${changeName}: ${err.message}`, "yellow");
+                    break;
+                  }
+                  if (!dirty)
+                    break;
+                  try {
+                    await bunCmdRunner.run(["git", "add", "-A"], cwd2);
+                    await bunCmdRunner.run(["git", "commit", "-m", `ralph: residual changes for ${changeName}`], cwd2);
+                    appendLog(`  committed residual changes for ${changeName}`, "gray");
+                    break;
+                  } catch (err) {
+                    const e = err;
+                    const detail = e.stderr?.trim() || e.message;
+                    const combined = `${e.stdout ?? ""}
+${e.stderr ?? ""}`;
+                    if (/nothing to commit/i.test(combined))
+                      break;
+                    if (commitFixAttempt >= maxHookFixAttempts) {
+                      appendLog(`! commit rejected for ${changeName} after ${commitFixAttempt} fix attempts (host pre-commit hook still failing) \u2014 worktree preserved at ${cwd2}`, "red");
+                      appendLog(`    detail: ${detail}`, "red");
+                      effectiveCode = PR_FAILED_EXIT;
+                      commitGaveUp = true;
+                      break;
+                    }
+                    commitFixAttempt += 1;
+                    appendLog(`! commit rejected for ${changeName} \u2014 feeding error back to worker (attempt ${commitFixAttempt}/${maxHookFixAttempts})`, "yellow");
+                    appendLog(`    detail: ${detail}`, "yellow");
+                    const retryCode = await runWorkerWithSteering(`Committing residual changes was rejected by the host repo's pre-commit hook. ` + `Fix the underlying problem reported below, then the commit will be retried.
 
-${steering}
-`;
-                            const next = prev.includes("## Steering") ? prev.replace(/## Steering\n+([\s\S]*?)$/, (_m, rest2) => `## Steering
-${stamped}
-${rest2}`) : prev + `
-## Steering
-${stamped}
-`;
-                            await Bun.write(proposalPath, next);
-                          } catch (err) {
-                            appendLog(`! could not append steering: ${err.message}`, "red");
-                          }
-                          const p = Bun.spawn({
-                            cmd: buildTaskCmd(),
-                            cwd: cwd2,
-                            stdout: "ignore",
-                            stderr: "ignore",
-                            stdin: "ignore"
-                          });
-                          return p.exited;
-                        },
-                        pushBranch: async () => {
-                          await bunCmdRunner.run(["git", "push", "origin", branch], cwd2);
-                        },
-                        log: appendLog,
-                        sleep: (ms) => new Promise((r) => setTimeout(r, ms))
-                      }, {
-                        maxAttempts: cfg.maxCiFixAttempts,
-                        pollIntervalSeconds: cfg.ciPollIntervalSeconds
-                      });
-                      if (!result2.success) {
-                        appendLog(`! CI fix loop gave up after ${result2.attempts} attempts (${result2.reason ?? "unknown"}) \u2014 withholding done-status until CI passes`, "red");
-                        effectiveCode = CI_FAILED_EXIT;
+` + "```\n" + combined.trim() + "\n```");
+                    if (retryCode !== 0) {
+                      appendLog(`! worker re-run after commit rejection exited code ${retryCode} \u2014 giving up`, "red");
+                      effectiveCode = PR_FAILED_EXIT;
+                      commitGaveUp = true;
+                      break;
+                    }
+                  }
+                }
+                let pushFixAttempt = 0;
+                let pr = null;
+                let prGaveUp = commitGaveUp;
+                while (!prGaveUp) {
+                  try {
+                    pr = await createPullRequest({ cwd: cwd2, branch, issue: prIssue, base: cfg.prBaseBranch }, bunCmdRunner);
+                    break;
+                  } catch (err) {
+                    const e = err;
+                    const detail = e.stderr?.trim() || e.message;
+                    const combined = `${e.stdout ?? ""}
+${e.stderr ?? ""}`;
+                    const pushRejected = /failed to push some refs|pre-push hook|hook declined/i.test(combined);
+                    if (!pushRejected || pushFixAttempt >= maxHookFixAttempts) {
+                      if (pushRejected) {
+                        appendLog(`! push rejected for ${changeName} after ${pushFixAttempt} fix attempts (host pre-push hook still failing) \u2014 worktree preserved at ${cwd2}`, "red");
+                        appendLog(`    detail: ${detail}`, "red");
+                      } else {
+                        appendLog(`! PR create failed for ${changeName}: ${detail}`, "red");
                       }
+                      effectiveCode = PR_FAILED_EXIT;
+                      prGaveUp = true;
+                      break;
+                    }
+                    pushFixAttempt += 1;
+                    appendLog(`! push rejected for ${changeName} \u2014 feeding error back to worker (attempt ${pushFixAttempt}/${maxHookFixAttempts})`, "yellow");
+                    appendLog(`    detail: ${detail}`, "yellow");
+                    const retryCode = await runWorkerWithSteering(`Push to origin/${branch} was rejected by the host repo's pre-push hook. ` + `Fix the underlying problem reported below, then the push will be retried.
+
+` + "```\n" + combined.trim() + "\n```");
+                    if (retryCode !== 0) {
+                      appendLog(`! worker re-run after push rejection exited code ${retryCode} \u2014 giving up`, "red");
+                      effectiveCode = PR_FAILED_EXIT;
+                      prGaveUp = true;
+                      break;
+                    }
+                  }
+                }
+                if (prGaveUp) {} else if (!pr) {
+                  appendLog(`  no commits ahead of ${cfg.prBaseBranch} \u2014 skipping PR`, "gray");
+                } else {
+                  appendLog(`  ${pr.created ? "opened" : "found existing"} PR: ${pr.url}`, "green");
+                  const wantFixCi = args.fixCi || cfg.fixCiOnFailure;
+                  if (wantFixCi) {
+                    appendLog(`  watching CI for ${pr.url} (max ${cfg.maxCiFixAttempts} fix attempts)`, "gray");
+                    const result2 = await fixCiUntilGreen({
+                      getStatus: () => getPrChecksStatus(pr.url, bunCmdRunner, cwd2),
+                      getFailedLogs: (ids) => fetchFailedRunLogs(ids, bunCmdRunner, cwd2),
+                      runTaskWithSteering: async (steering) => {
+                        try {
+                          await appendSteering(proposalPath, `CI feedback:
+
+${steering}`);
+                        } catch (err) {
+                          appendLog(`! could not append steering: ${err.message}`, "red");
+                        }
+                        const p = Bun.spawn({
+                          cmd: buildTaskCmd(),
+                          cwd: cwd2,
+                          stdout: "ignore",
+                          stderr: "ignore",
+                          stdin: "ignore"
+                        });
+                        return p.exited;
+                      },
+                      pushBranch: async () => {
+                        await bunCmdRunner.run(["git", "push", "origin", branch], cwd2);
+                      },
+                      log: appendLog,
+                      sleep: (ms) => new Promise((r) => setTimeout(r, ms))
+                    }, {
+                      maxAttempts: cfg.maxCiFixAttempts,
+                      pollIntervalSeconds: cfg.ciPollIntervalSeconds
+                    });
+                    if (!result2.success) {
+                      appendLog(`! CI fix loop gave up after ${result2.attempts} attempts (${result2.reason ?? "unknown"}) \u2014 withholding done-status until CI passes`, "red");
+                      effectiveCode = CI_FAILED_EXIT;
                     }
                   }
-                } catch (err) {
-                  const e = err;
-                  const detail = e.stderr?.trim() || e.message;
-                  appendLog(`! PR create failed for ${changeName}: ${detail}`, "red");
-                  effectiveCode = PR_FAILED_EXIT;
                 }
               }
             }
             if (useWorktree && cwd2 !== projectRoot) {
               if (effectiveCode === 0 && cfg.cleanupWorktreeOnSuccess) {
-                try {
-                  await removeWorktree(projectRoot, cwd2, bunGitRunner);
-                  appendLog(`  removed worktree ${cwd2}`, "gray");
-                } catch (err) {
-                  appendLog(`! worktree remove failed for ${changeName}: ${err.message}`, "yellow");
+                const check = await isWorktreeSafeToRemove(cwd2, cfg.prBaseBranch, bunGitRunner).catch((err) => ({
+                  safe: false,
+                  reason: `safety check failed: ${err.message}`,
+                  dirty: "",
+                  unpushedCommits: ""
+                }));
+                if (!check.safe) {
+                  appendLog(`! preserving worktree for ${changeName}: ${check.reason}`, "yellow");
+                  if (check.dirty) {
+                    appendLog(`    uncommitted:
+${check.dirty}`, "yellow");
+                  }
+                  if (check.unpushedCommits) {
+                    appendLog(`    commits:
+${check.unpushedCommits}`, "yellow");
+                  }
+                  appendLog(`    path: ${cwd2}`, "yellow");
+                } else {
+                  try {
+                    await removeWorktree(projectRoot, cwd2, bunGitRunner);
+                    appendLog(`  removed worktree ${cwd2}`, "gray");
+                  } catch (err) {
+                    appendLog(`! worktree remove failed for ${changeName}: ${err.message}`, "yellow");
+                  }
                 }
               }
             }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@neriros/ralphy",
-  "version": "2.9.1",
+  "version": "2.9.3",
   "description": "An iterative AI task execution framework. Orchestrates multi-phase autonomous work using Claude or Codex engines.",
   "keywords": [
     "agent",