@neriros/ralphy 2.23.1 → 2.23.2

package/README.md

@@ -240,14 +240,15 @@ Done issues whose PR `gh pr view --json mergeable` reports as `CONFLICTING` get
 
 ### PR + CI integration
 
-| Flag / config                         | Behavior                                                                                                                                                                                                                                                                                                                                                                                                            |
-| ------------------------------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
-| `createPrOnSuccess` / `--create-pr`   | After a clean exit, push the worker's branch and `gh pr create`. Title: `<ID>: <title>`. Idempotent — surfaces the existing URL if the PR is already open. Requires `--worktree` and `gh` authenticated. `prBaseBranch` defaults to `main`; override per-issue by labelling the Linear issue with `ralph:branch:<branch-name>`.                                                                                     |
-| `getAutoMerge` indicator              | Opt an issue in for GitHub auto-merge (any-of label/status filter, same shape as `getReview`). When matched, Ralph runs `gh pr merge <url> --auto --<strategy>` right after opening the PR so GitHub merges as soon as required checks pass. Strategy comes from `autoMergeStrategy` (`squash` \| `merge` \| `rebase`, default `squash`). Failures are logged but non-fatal — the CI/conflict watch loop continues. |
-| `fixCiOnFailure` / `--fix-ci`         | After the PR opens, poll `gh pr checks`. On failure, pull failed logs via `gh run view --log-failed`, append them to `## Steering`, re-spawn the worker, and push the new commits — repeat until green or `maxCiFixAttempts` (default `5`) is hit. While this loop runs, `setDone` is **not** applied; if CI is never green the worker is treated as failed.                                                        |
-| `ciPollIntervalSeconds`               | Seconds between CI status polls (default `30`).                                                                                                                                                                                                                                                                                                                                                                     |
-| `ignoreCiChecks`                      | Array of check names to ignore when computing pass/fail.                                                                                                                                                                                                                                                                                                                                                            |
-| `codeReviewTrigger` / `--code-review` | See [Code-review iteration](#code-review-iteration).                                                                                                                                                                                                                                                                                                                                                                |
+| Flag / config                            | Behavior                                                                                                                                                                                                                                                                                                                                                                                                            |
+| ---------------------------------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| `createPrOnSuccess` / `--create-pr`      | After a clean exit, push the worker's branch and `gh pr create`. Title: `<ID>: <title>`. Idempotent — surfaces the existing URL if the PR is already open. Requires `--worktree` and `gh` authenticated. `prBaseBranch` defaults to `main`; override per-issue by labelling the Linear issue with `ralph:branch:<branch-name>`.                                                                                     |
+| `stackPrsOnDependencies` / `--stack-prs` | When the Linear issue is blocked by another issue (`blocked_by` relation) that has exactly one open GitHub PR, open this PR against that blocker's head branch instead of `prBaseBranch`. Resolves the blocker's PR via Linear's auto-attachment + `gh pr view --json state,headRefName`. Falls back to `prBaseBranch` when zero / multiple blockers (or PRs) match. A `ralph:branch:<name>` label still wins.      |
+| `getAutoMerge` indicator                 | Opt an issue in for GitHub auto-merge (any-of label/status filter, same shape as `getReview`). When matched, Ralph runs `gh pr merge <url> --auto --<strategy>` right after opening the PR so GitHub merges as soon as required checks pass. Strategy comes from `autoMergeStrategy` (`squash` \| `merge` \| `rebase`, default `squash`). Failures are logged but non-fatal — the CI/conflict watch loop continues. |
+| `fixCiOnFailure` / `--fix-ci`            | After the PR opens, poll `gh pr checks`. On failure, pull failed logs via `gh run view --log-failed`, append them to `## Steering`, re-spawn the worker, and push the new commits — repeat until green or `maxCiFixAttempts` (default `5`) is hit. While this loop runs, `setDone` is **not** applied; if CI is never green the worker is treated as failed.                                                        |
+| `ciPollIntervalSeconds`                  | Seconds between CI status polls (default `30`).                                                                                                                                                                                                                                                                                                                                                                     |
+| `ignoreCiChecks`                         | Array of check names to ignore when computing pass/fail.                                                                                                                                                                                                                                                                                                                                                            |
+| `codeReviewTrigger` / `--code-review`    | See [Code-review iteration](#code-review-iteration).                                                                                                                                                                                                                                                                                                                                                                |
 
 ### Worktrees, setup, teardown
 
@@ -302,19 +303,20 @@ Failed workers are not marked processed, so they retry on the next poll. SIGINT
 
 **Agent-mode flags**
 
-| Option                    | Behavior                                                                             |
-| ------------------------- | ------------------------------------------------------------------------------------ |
-| `--linear-team <key>`     | Linear team key (e.g. `ENG`)                                                         |
-| `--linear-assignee <id>`  | Assignee filter (user id, email, or `me`)                                            |
-| `--poll-interval <s>`     | Seconds between Linear polls (default `60`)                                          |
-| `--concurrency <n>`       | Max concurrent task loops (default `1`)                                              |
-| `--max-tickets <n>`       | Stop picking up new issues after N have been started this run (`0` = unlimited)      |
-| `--worktree`              | Run each task in its own git worktree                                                |
-| `--indicator <k>:<t>:<v>` | Override one `linear.indicators` entry (repeatable, e.g. `setDone:status:Done`)      |
-| `--create-pr`             | Push worker branch + open a GitHub PR on success (needs `--worktree`)                |
-| `--fix-ci`                | After PR opens, re-run task on CI failures until green (needs `--create-pr`)         |
-| `--code-review`           | Watch open tracked PRs for unresolved review comments and prepend a code-review task |
-| `--json-output`           | Emit JSONL to stdout instead of rendering the Ink dashboard (CI / scripting)         |
+| Option                    | Behavior                                                                                     |
+| ------------------------- | -------------------------------------------------------------------------------------------- |
+| `--linear-team <key>`     | Linear team key (e.g. `ENG`)                                                                 |
+| `--linear-assignee <id>`  | Assignee filter (user id, email, or `me`)                                                    |
+| `--poll-interval <s>`     | Seconds between Linear polls (default `60`)                                                  |
+| `--concurrency <n>`       | Max concurrent task loops (default `1`)                                                      |
+| `--max-tickets <n>`       | Stop picking up new issues after N have been started this run (`0` = unlimited)              |
+| `--worktree`              | Run each task in its own git worktree                                                        |
+| `--indicator <k>:<t>:<v>` | Override one `linear.indicators` entry (repeatable, e.g. `setDone:status:Done`)              |
+| `--create-pr`             | Push worker branch + open a GitHub PR on success (needs `--worktree`)                        |
+| `--fix-ci`                | After PR opens, re-run task on CI failures until green (needs `--create-pr`)                 |
+| `--stack-prs`             | Open the PR against a blocker issue's open-PR head branch when present (needs `--create-pr`) |
+| `--code-review`           | Watch open tracked PRs for unresolved review comments and prepend a code-review task         |
+| `--json-output`           | Emit JSONL to stdout instead of rendering the Ink dashboard (CI / scripting)                 |
 
 **List-mode flags**
 

package/dist/cli/index.js

@@ -9553,7 +9553,7 @@ Learn more about this warning here: https://reactjs.org/link/legacy-context`, so
 
 ` + ("" + errorBoundaryMessage);
             console["error"](combinedMessage);
-          } else {}
+          }
         } catch (e) {
           setTimeout(function() {
             throw e;
@@ -18037,7 +18037,7 @@ var require_backend = __commonJS((exports, module) => {
         987: (module2, __unused_webpack_exports, __webpack_require__2) => {
           if (true) {
             module2.exports = __webpack_require__2(786);
-          } else {}
+          }
         },
         126: (__unused_webpack_module, exports2, __webpack_require__2) => {
           var process3 = __webpack_require__2(169);
@@ -18487,7 +18487,7 @@ var require_backend = __commonJS((exports, module) => {
         189: (module2, __unused_webpack_exports, __webpack_require__2) => {
           if (true) {
             module2.exports = __webpack_require__2(126);
-          } else {}
+          }
         },
         206: function(module2, exports2, __webpack_require__2) {
           var __WEBPACK_AMD_DEFINE_FACTORY__, __WEBPACK_AMD_DEFINE_ARRAY__, __WEBPACK_AMD_DEFINE_RESULT__;
@@ -18502,7 +18502,7 @@ var require_backend = __commonJS((exports, module) => {
           (function(root, factory) {
             if (true) {
               __WEBPACK_AMD_DEFINE_ARRAY__ = [__webpack_require__2(430)], __WEBPACK_AMD_DEFINE_FACTORY__ = factory, __WEBPACK_AMD_DEFINE_RESULT__ = typeof __WEBPACK_AMD_DEFINE_FACTORY__ === "function" ? __WEBPACK_AMD_DEFINE_FACTORY__.apply(exports2, __WEBPACK_AMD_DEFINE_ARRAY__) : __WEBPACK_AMD_DEFINE_FACTORY__, __WEBPACK_AMD_DEFINE_RESULT__ !== undefined && (module2.exports = __WEBPACK_AMD_DEFINE_RESULT__);
-            } else {}
+            }
           })(this, function ErrorStackParser(StackFrame) {
             var FIREFOX_SAFARI_STACK_REGEXP = /(^|@)\S+:\d+/;
             var CHROME_IE_STACK_REGEXP = /^\s*at .*(\S+:\d+|\(native\))/m;
@@ -19198,7 +19198,7 @@ var require_backend = __commonJS((exports, module) => {
           (function(root, factory) {
             if (true) {
               __WEBPACK_AMD_DEFINE_ARRAY__ = [], __WEBPACK_AMD_DEFINE_FACTORY__ = factory, __WEBPACK_AMD_DEFINE_RESULT__ = typeof __WEBPACK_AMD_DEFINE_FACTORY__ === "function" ? __WEBPACK_AMD_DEFINE_FACTORY__.apply(exports2, __WEBPACK_AMD_DEFINE_ARRAY__) : __WEBPACK_AMD_DEFINE_FACTORY__, __WEBPACK_AMD_DEFINE_RESULT__ !== undefined && (module2.exports = __WEBPACK_AMD_DEFINE_RESULT__);
-            } else {}
+            }
           })(this, function() {
             function _isNumber(n) {
               return !isNaN(parseFloat(n)) && isFinite(n);
@@ -24572,7 +24572,7 @@ In order to be iterable, non-array objects must have a [Symbol.iterator]() metho
           var suffix = "";
           if (true) {
             suffix = " (<anonymous>)";
-          } else {}
+          }
           return `
 ` + prefix + name + suffix;
         }
@@ -27301,7 +27301,7 @@ In order to be iterable, non-array objects must have a [Symbol.iterator]() metho
                     hasChanges = true;
                     updateMostRecentlyInspectedElementIfNecessary(devtoolsInstance.id);
                   }
-                } else {}
+                }
               }
             } catch (err) {
               _iterator2.e(err);
@@ -29080,7 +29080,7 @@ In order to be iterable, non-array objects must have a [Symbol.iterator]() metho
                       if (contentFiber === null) {
                         throw new Error("There should always be an Offscreen Fiber child in a hydrated Suspense boundary.");
                       }
-                    } else {}
+                    }
                     var _isTimedOut = fiber.memoizedState !== null;
                     if (!_isTimedOut) {
                       newSuspenseNode.rects = measureInstance(newInstance);
@@ -29114,7 +29114,7 @@ In order to be iterable, non-array objects must have a [Symbol.iterator]() metho
                     if (_contentFiber === null) {
                       throw new Error("There should always be an Offscreen Fiber child in a hydrated Suspense boundary.");
                     }
-                  } else {}
+                  }
                   var suspenseState = fiber.memoizedState;
                   var _isTimedOut3 = suspenseState !== null;
                   if (!_isTimedOut3) {
@@ -29214,7 +29214,7 @@ In order to be iterable, non-array objects must have a [Symbol.iterator]() metho
                   trackThrownPromisesFromRetryCache(newSuspenseNode, fiber.stateNode);
                   mountSuspenseChildrenRecursively(_contentFiber2, traceNearestHostComponentUpdate, stashedSuspenseParent, stashedSuspensePrevious, stashedSuspenseRemaining);
                   shouldPopSuspenseNode = false;
-                } else {}
+                }
               } else {
                 if (fiber.child !== null) {
                   mountChildrenRecursively(fiber.child, traceNearestHostComponentUpdate);
@@ -29800,7 +29800,7 @@ In order to be iterable, non-array objects must have a [Symbol.iterator]() metho
                   shouldPopSuspenseNode = false;
                 } else if (previousHydrated && !nextHydrated) {
                   throw new Error("Encountered a dehydrated Suspense boundary that was previously hydrated.");
-                } else {}
+                }
               } else {
                 if (nextFiber.child !== prevFiber.child) {
                   updateFlags |= updateChildrenRecursively(nextFiber.child, prevFiber.child, traceNearestHostComponentUpdate);
@@ -29846,8 +29846,8 @@ In order to be iterable, non-array objects must have a [Symbol.iterator]() metho
                     recordResetChildren(fiberInstance);
                   }
                   updateFlags &= ~ShouldResetChildren;
-                } else {}
-              } else {}
+                }
+              }
               if ((updateFlags & ShouldResetSuspenseChildren) !== NoUpdate) {
                 if (fiberInstance !== null && fiberInstance.kind === FIBER_INSTANCE) {
                   var _suspenseNode3 = fiberInstance.suspenseNode;
@@ -29855,7 +29855,7 @@ In order to be iterable, non-array objects must have a [Symbol.iterator]() metho
                     recordResetSuspenseChildren(_suspenseNode3);
                     updateFlags &= ~ShouldResetSuspenseChildren;
                   }
-                } else {}
+                }
               }
               if ((updateFlags & ShouldResetParentSuspenseChildren) !== NoUpdate) {
                 if (fiberInstance !== null && fiberInstance.kind === FIBER_INSTANCE) {
@@ -29864,7 +29864,7 @@ In order to be iterable, non-array objects must have a [Symbol.iterator]() metho
                     updateFlags &= ~ShouldResetParentSuspenseChildren;
                     updateFlags |= ShouldResetSuspenseChildren;
                   }
-                } else {}
+                }
               }
               return updateFlags;
             } finally {
@@ -32928,7 +32928,7 @@ The error thrown in the component is:
               rendererInterface = renderer_attach(hook, id, renderer, global2, shouldStartProfilingNow, profilingSettings);
             } else if (renderer.ComponentTree) {
               rendererInterface = legacy_renderer_attach(hook, id, renderer, global2);
-            } else {}
+            }
           }
           return rendererInterface;
         }
@@ -35029,8 +35029,8 @@ import { readFileSync as readFileSync2 } from "fs";
 import { resolve } from "path";
 function getVersion() {
   try {
-    if ("2.23.1")
-      return "2.23.1";
+    if ("2.23.2")
+      return "2.23.2";
   } catch {}
   const dirsToTry = [];
   try {
@@ -35124,6 +35124,7 @@ async function parseArgs(argv) {
     indicators: {},
     createPr: false,
     fixCi: false,
+    stackPrs: false,
     codeReview: false,
     maxTickets: 0,
     projectRoot: undefined,
@@ -35319,6 +35320,9 @@ async function parseArgs(argv) {
       case "--fix-ci":
         result2.fixCi = true;
         break;
+      case "--stack-prs":
+        result2.stackPrs = true;
+        break;
       case "--code-review":
         result2.codeReview = true;
         break;
@@ -35423,6 +35427,7 @@ var init_cli = __esm(() => {
     "                          (attachment upserts a single 'Ralphy' entry; value = subtitle)",
     "  --create-pr             Push the worker branch and open a GitHub PR on success (needs --worktree)",
     "  --fix-ci                After opening the PR, re-run on CI failures until green (needs --create-pr)",
+    "  --stack-prs             Base the PR on a blocker issue's open-PR head branch when present (needs --create-pr)",
     "  --code-review           Watch open tracked PRs for unresolved review comments and prepend a code-review task",
     "  --max-tickets <n>       Stop picking up new issues after N have been started (0 = unlimited)",
     "  --json-output           Emit JSONL to stdout instead of the Ink dashboard (for scripting/CI)",
@@ -59526,6 +59531,12 @@ var MarkerSchema, GetIndicatorSchema, SetIndicatorSchema, IndicatorsSchema, Ralp
   // Linear issue with "ralph:branch:<branch-name>".
   "prBaseBranch": "main",
 
+  // When true, if the Linear issue is blocked by another issue whose
+  // single open GitHub PR can be resolved (via Linear's auto-attachment),
+  // open this PR against that blocker's head branch instead of prBaseBranch.
+  // A "ralph:branch:<name>" label on the issue still wins over this.
+  "stackPrsOnDependencies": false,
+
   // Merge strategy used when GitHub auto-merge is enabled (see getAutoMerge
   // indicator below). One of "squash", "merge", "rebase".
   "autoMergeStrategy": "squash",
@@ -59679,6 +59690,7 @@ var init_config = __esm(() => {
     appendPrompt: exports_external.string().optional(),
     createPrOnSuccess: exports_external.boolean().default(false),
     prBaseBranch: exports_external.string().default("main"),
+    stackPrsOnDependencies: exports_external.boolean().default(false),
     autoMergeStrategy: exports_external.enum(["squash", "merge", "rebase"]).default("squash"),
     fixCiOnFailure: exports_external.boolean().default(false),
     maxCiFixAttempts: exports_external.number().int().positive().default(5),
@@ -61155,15 +61167,33 @@ async function runPrPhase(input, deps) {
     wantAutoMerge,
     cfg
   } = input;
-  const { cmd, log: log2, emit, respawnWorker, registerPr, checkPrConflict } = deps;
+  const {
+    cmd,
+    log: log2,
+    emit,
+    respawnWorker,
+    registerPr,
+    checkPrConflict,
+    resolveDependencyBaseBranch
+  } = deps;
   if (!branch || !issue) {
     log2(`! createPr requested but no worktree branch is tracked for ${changeName} (use --worktree)`, "yellow");
     return PR_FAILED_EXIT;
   }
   const labelBase = baseBranchFromLabels(issue.labels);
-  const base2 = labelBase ?? cfg.prBaseBranch;
+  let base2 = labelBase ?? cfg.prBaseBranch;
   if (labelBase && labelBase !== cfg.prBaseBranch) {
     log2(`  base branch override from label: ${labelBase}`, "gray");
+  } else if (cfg.stackPrsOnDependencies && resolveDependencyBaseBranch) {
+    try {
+      const dependencyBase = await resolveDependencyBaseBranch(issue);
+      if (dependencyBase && dependencyBase !== base2) {
+        log2(`  base branch override from blocker PR: ${dependencyBase}`, "gray");
+        base2 = dependencyBase;
+      }
+    } catch (err) {
+      log2(`! could not resolve dependency base branch for ${issue.identifier}: ${err.message}`, "yellow");
+    }
   }
   const ctx = {
     changeName,
@@ -61291,7 +61321,8 @@ async function runPostTask(input, deps) {
       emit,
       respawnWorker,
       ...deps.registerPr !== undefined ? { registerPr: deps.registerPr } : {},
-      ...deps.checkPrConflict !== undefined ? { checkPrConflict: deps.checkPrConflict } : {}
+      ...deps.checkPrConflict !== undefined ? { checkPrConflict: deps.checkPrConflict } : {},
+      ...deps.resolveDependencyBaseBranch !== undefined ? { resolveDependencyBaseBranch: deps.resolveDependencyBaseBranch } : {}
     });
   }
   emit(effectiveCode === 0 ? "done" : "gave-up", effectiveCode !== 0 ? `exit ${effectiveCode}` : undefined);
@@ -61839,7 +61870,8 @@ PR: ${prUrl}` : ""
           maxCiFixAttempts: cfg.maxCiFixAttempts,
           ciPollIntervalSeconds: cfg.ciPollIntervalSeconds,
           cleanupWorktreeOnSuccess: cfg.cleanupWorktreeOnSuccess,
-          ignoreCiChecks: cfg.ignoreCiChecks
+          ignoreCiChecks: cfg.ignoreCiChecks,
+          stackPrsOnDependencies: args.stackPrs || cfg.stackPrsOnDependencies
         },
         respawnWorker: respawn
       }, {
@@ -61868,7 +61900,8 @@ PR: ${prUrl}` : ""
             await new Promise((r) => setTimeout(r, 2000));
           }
           return false;
-        }
+        },
+        resolveDependencyBaseBranch: (issue) => resolveDependencyBaseBranch(issue, tracedCmd, cwd2)
       });
       cwdByChange.delete(changeName);
       statesDirByChange.delete(changeName);
@@ -61956,6 +61989,45 @@ PR: ${prUrl}` : ""
     markPrUnavailable(changeName);
     return null;
   }
+  async function resolveDependencyBaseBranch(issue, runner, runnerCwd) {
+    const blockerIds = issue.blockedByIds;
+    if (blockerIds.length === 0)
+      return null;
+    const candidates = [];
+    for (const blockerId of blockerIds) {
+      let attachments;
+      try {
+        attachments = await fetchIssueAttachments(apiKey, blockerId);
+      } catch (err) {
+        onLog(`! could not fetch attachments for blocker ${blockerId} of ${issue.identifier}: ${err.message}`, "yellow");
+        continue;
+      }
+      const prUrls = attachments.map((a) => a.url).filter((url) => /^https:\/\/github\.com\/[^/]+\/[^/]+\/pull\/\d+/.test(url));
+      const openHeads = [];
+      for (const url of prUrls) {
+        try {
+          const res = await runner.run(["gh", "pr", "view", url, "--json", "state,headRefName", "--jq", "."], runnerCwd);
+          const parsed = JSON.parse(res.stdout.trim());
+          if (parsed.state === "OPEN" && parsed.headRefName) {
+            openHeads.push(parsed.headRefName);
+          }
+        } catch (err) {
+          onLog(`! gh pr view failed for ${url} (blocker of ${issue.identifier}): ${err.message}`, "yellow");
+        }
+      }
+      if (openHeads.length === 1) {
+        candidates.push(openHeads[0]);
+      } else if (openHeads.length > 1) {
+        onLog(`  ${issue.identifier}: blocker ${blockerId} has ${openHeads.length} open PRs \u2014 skipping dependency base resolution`, "gray");
+      }
+    }
+    if (candidates.length === 1)
+      return candidates[0];
+    if (candidates.length > 1) {
+      onLog(`  ${issue.identifier}: ${candidates.length} blockers have open PRs \u2014 falling back to default base`, "gray");
+    }
+    return null;
+  }
   async function discoverPrUrlFromLinear(issue) {
     try {
       const attachments = await fetchIssueAttachments(apiKey, issue.id);

package/dist/mcp/index.js

@@ -14104,7 +14104,7 @@ function finalize(ctx, schema) {
     result.$schema = "http://json-schema.org/draft-07/schema#";
   } else if (ctx.target === "draft-04") {
     result.$schema = "http://json-schema.org/draft-04/schema#";
-  } else if (ctx.target === "openapi-3.0") {} else {}
+  } else if (ctx.target === "openapi-3.0") {}
   if (ctx.external?.uri) {
     const id = ctx.external.registry.get(schema)?.id;
     if (!id)
@@ -14352,7 +14352,7 @@ var literalProcessor = (schema, ctx, json, _params) => {
     if (val === undefined) {
       if (ctx.unrepresentable === "throw") {
         throw new Error("Literal `undefined` cannot be represented in JSON Schema");
-      } else {}
+      }
     } else if (typeof val === "bigint") {
       if (ctx.unrepresentable === "throw") {
         throw new Error("BigInt literals cannot be represented in JSON Schema");

package/package.json

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