@rainy-updates/cli 0.5.1-rc.1 → 0.5.1-rc.2

package/CHANGELOG.md

@@ -2,6 +2,27 @@
 
 All notable changes to this project are documented in this file.
 
+## [0.5.1-rc.2] - 2026-02-27
+
+### Added
+
+- CI fix-PR batch automation:
+  - `ci --fix-pr` now creates batched branches from a shared base ref using git worktrees.
+  - New flag: `--fix-pr-batch-size <n>` to control groups per branch batch.
+- New summary/output metadata:
+  - `fixPrBranchesCreated`
+  - `fix_pr_branches_created` GitHub output key.
+
+### Changed
+
+- `ci --fix-pr --group-by scope` now supports multi-branch batch creation for scoped dependency flows.
+- `runCi` now consistently performs CI analysis flow first, with fix-PR handled by dedicated batch automation.
+
+### Tests
+
+- Added batch planning tests for fix-PR branch creation.
+- Extended parser tests for `--fix-pr-batch-size`.
+
 ## [0.5.1-rc.1] - 2026-02-27
 
 ### Added

package/README.md

@@ -40,6 +40,9 @@ npx @rainy-updates/cli check --workspace --ci --format json --json-file .artifac
 # 2b) CI orchestration mode
 npx @rainy-updates/cli ci --workspace --mode strict --format github --json-file .artifacts/updates.json
 
+# 2c) Batch fix branches by scope
+npx @rainy-updates/cli ci --workspace --mode enterprise --group-by scope --fix-pr --fix-pr-batch-size 2
+
 # 3) Apply upgrades with workspace sync
 npx @rainy-updates/cli upgrade --target latest --workspace --sync --install
 
@@ -161,6 +164,7 @@ Schedule:
 - `--pr-limit <n>`
 - `--only-changed`
 - `--mode minimal|strict|enterprise` (for `ci`)
+- `--fix-pr-batch-size <n>` (for batched fix branches in `ci`)
 - `--policy-file <path>`
 - `--format table|json|minimal|github`
 - `--json-file <path>`

package/dist/bin/cli.js

@@ -11,6 +11,7 @@ import { runCi } from "../core/ci.js";
 import { initCiWorkflow } from "../core/init-ci.js";
 import { diffBaseline, saveBaseline } from "../core/baseline.js";
 import { applyFixPr } from "../core/fix-pr.js";
+import { applyFixPrBatches } from "../core/fix-pr-batch.js";
 import { renderResult } from "../output/format.js";
 import { writeGitHubOutput } from "../output/github.js";
 import { createSarifReport } from "../output/sarif.js";
@@ -74,10 +75,24 @@ async function main() {
             result.summary.fixPrApplied = false;
             result.summary.fixBranchName = parsed.options.fixBranch ?? "chore/rainy-updates";
             result.summary.fixCommitSha = "";
-            const fixResult = await applyFixPr(parsed.options, result, parsed.options.prReportFile ? [parsed.options.prReportFile] : []);
-            result.summary.fixPrApplied = fixResult.applied;
-            result.summary.fixBranchName = fixResult.branchName ?? "";
-            result.summary.fixCommitSha = fixResult.commitSha ?? "";
+            result.summary.fixPrBranchesCreated = 0;
+            if (parsed.command === "ci") {
+                const batched = await applyFixPrBatches(parsed.options, result);
+                result.summary.fixPrApplied = batched.applied;
+                result.summary.fixBranchName = batched.branches[0] ?? (parsed.options.fixBranch ?? "chore/rainy-updates");
+                result.summary.fixCommitSha = batched.commits[0] ?? "";
+                result.summary.fixPrBranchesCreated = batched.branches.length;
+                if (batched.branches.length > 1) {
+                    result.warnings.push(`Created ${batched.branches.length} fix-pr batch branches.`);
+                }
+            }
+            else {
+                const fixResult = await applyFixPr(parsed.options, result, parsed.options.prReportFile ? [parsed.options.prReportFile] : []);
+                result.summary.fixPrApplied = fixResult.applied;
+                result.summary.fixBranchName = fixResult.branchName ?? "";
+                result.summary.fixCommitSha = fixResult.commitSha ?? "";
+                result.summary.fixPrBranchesCreated = fixResult.applied ? 1 : 0;
+            }
         }
         result.summary.failReason = resolveFailReason(result.updates, result.errors, parsed.options.failOn, parsed.options.maxUpdates, parsed.options.ci);
         const renderStartedAt = Date.now();
@@ -134,6 +149,7 @@ Options:
   --fix-commit-message <text>
   --fix-dry-run
   --fix-pr-no-checkout
+  --fix-pr-batch-size <n>
   --no-pr-report
   --json-file <path>
   --github-output <path>
@@ -186,6 +202,7 @@ Options:
   --fix-commit-message <text>
   --fix-dry-run
   --fix-pr-no-checkout
+  --fix-pr-batch-size <n>
   --no-pr-report
   --json-file <path>
   --pr-report-file <path>`;
@@ -210,6 +227,7 @@ Options:
   --fix-commit-message <text>
   --fix-dry-run
   --fix-pr-no-checkout
+  --fix-pr-batch-size <n>
   --no-pr-report
   --json-file <path>
   --github-output <path>
@@ -277,6 +295,7 @@ Global options:
   --fix-commit-message <text>
   --fix-dry-run
   --fix-pr-no-checkout
+  --fix-pr-batch-size <n>
   --no-pr-report
   --log-level error|warn|info|debug
   --concurrency <n>

package/dist/config/loader.d.ts

@@ -22,6 +22,7 @@ export interface FileConfig {
     fixCommitMessage?: string;
     fixDryRun?: boolean;
     fixPrNoCheckout?: boolean;
+    fixPrBatchSize?: number;
     noPrReport?: boolean;
     logLevel?: LogLevel;
     groupBy?: GroupBy;

package/dist/core/ci.js

@@ -1,6 +1,5 @@
 import { check } from "./check.js";
 import { warmCache } from "./warm-cache.js";
-import { upgrade } from "./upgrade.js";
 export async function runCi(options) {
     const profile = options.ciProfile;
     if (profile !== "minimal") {
@@ -17,14 +16,5 @@ export async function runCi(options) {
         offline: profile === "minimal" ? options.offline : true,
         concurrency: profile === "enterprise" ? Math.max(options.concurrency, 32) : options.concurrency,
     };
-    if (options.fixPr) {
-        const upgradeOptions = {
-            ...checkOptions,
-            install: false,
-            packageManager: "auto",
-            sync: false,
-        };
-        return await upgrade(upgradeOptions);
-    }
     return await check(checkOptions);
 }

package/dist/core/fix-pr-batch.d.ts

@@ -0,0 +1,19 @@
+import type { CheckResult, PackageUpdate, RunOptions } from "../types/index.js";
+export interface FixPrBatchResult {
+    applied: boolean;
+    branches: string[];
+    commits: string[];
+}
+interface UpdateGroup {
+    key: string;
+    items: PackageUpdate[];
+}
+interface PlannedBatch {
+    index: number;
+    groups: UpdateGroup[];
+    updates: PackageUpdate[];
+    branchName: string;
+}
+export declare function applyFixPrBatches(options: RunOptions, result: CheckResult): Promise<FixPrBatchResult>;
+export declare function planFixPrBatches(groups: UpdateGroup[], baseBranch: string, batchSize: number): PlannedBatch[];
+export {};

package/dist/core/fix-pr-batch.js

@@ -0,0 +1,172 @@
+import { spawn } from "node:child_process";
+import { promises as fs } from "node:fs";
+import os from "node:os";
+import path from "node:path";
+import { readManifest, writeManifest } from "../parsers/package-json.js";
+export async function applyFixPrBatches(options, result) {
+    if (!options.fixPr || result.updates.length === 0) {
+        return { applied: false, branches: [], commits: [] };
+    }
+    const baseRef = await resolveBaseRef(options.cwd, options.fixPrNoCheckout);
+    const groups = groupUpdates(result.updates, options.groupBy);
+    const plans = planFixPrBatches(groups, options.fixBranch ?? "chore/rainy-updates", options.fixPrBatchSize ?? 1);
+    if (options.fixDryRun) {
+        return { applied: false, branches: plans.map((plan) => plan.branchName), commits: [] };
+    }
+    const branches = [];
+    const commits = [];
+    for (const plan of plans) {
+        const tempDir = await fs.mkdtemp(path.join(os.tmpdir(), "rainy-fix-pr-batch-"));
+        try {
+            await runGit(options.cwd, ["worktree", "add", "-B", plan.branchName, tempDir, baseRef]);
+            await applyUpdatesInWorktree(options.cwd, tempDir, plan.updates);
+            await stageUpdatedManifests(options.cwd, tempDir, plan.updates);
+            const message = renderCommitMessage(options, plan, plans.length);
+            await runGit(tempDir, ["commit", "-m", message]);
+            const rev = await runGit(tempDir, ["rev-parse", "HEAD"]);
+            branches.push(plan.branchName);
+            commits.push(rev.stdout.trim());
+        }
+        finally {
+            await runGit(options.cwd, ["worktree", "remove", "--force", tempDir], true);
+        }
+    }
+    return {
+        applied: branches.length > 0,
+        branches,
+        commits,
+    };
+}
+export function planFixPrBatches(groups, baseBranch, batchSize) {
+    if (groups.length === 0)
+        return [];
+    const size = Math.max(1, Math.floor(batchSize));
+    const chunks = [];
+    for (let index = 0; index < groups.length; index += size) {
+        chunks.push(groups.slice(index, index + size));
+    }
+    return chunks.map((chunk, index) => {
+        const suffix = chunk.length === 1 ? sanitizeBranchToken(chunk[0]?.key ?? `batch-${index + 1}`) : `batch-${index + 1}`;
+        return {
+            index: index + 1,
+            groups: chunk,
+            updates: chunk.flatMap((item) => item.items),
+            branchName: `${baseBranch}-${suffix}`,
+        };
+    });
+}
+function groupUpdates(updates, groupBy) {
+    if (updates.length === 0)
+        return [];
+    if (groupBy === "none") {
+        return [{ key: "all", items: sortUpdates(updates) }];
+    }
+    const byGroup = new Map();
+    for (const update of updates) {
+        const key = groupKey(update, groupBy);
+        byGroup.set(key, [...(byGroup.get(key) ?? []), update]);
+    }
+    return Array.from(byGroup.entries())
+        .map(([key, items]) => ({ key, items: sortUpdates(items) }))
+        .sort((left, right) => left.key.localeCompare(right.key));
+}
+function groupKey(update, groupBy) {
+    if (groupBy === "name")
+        return update.name;
+    if (groupBy === "kind")
+        return update.kind;
+    if (groupBy === "risk")
+        return update.diffType;
+    if (groupBy === "scope") {
+        if (update.name.startsWith("@")) {
+            const slash = update.name.indexOf("/");
+            if (slash > 1)
+                return update.name.slice(0, slash);
+        }
+        return "unscoped";
+    }
+    return "all";
+}
+function sortUpdates(updates) {
+    return [...updates].sort((left, right) => {
+        const byPath = left.packagePath.localeCompare(right.packagePath);
+        if (byPath !== 0)
+            return byPath;
+        const byName = left.name.localeCompare(right.name);
+        if (byName !== 0)
+            return byName;
+        return left.kind.localeCompare(right.kind);
+    });
+}
+async function resolveBaseRef(cwd, allowDetached) {
+    const status = await runGit(cwd, ["status", "--porcelain"]);
+    if (status.stdout.trim().length > 0) {
+        throw new Error("Cannot run --fix-pr with a dirty git working tree.");
+    }
+    const headRef = await runGit(cwd, ["symbolic-ref", "--quiet", "--short", "HEAD"], true);
+    if (headRef.code === 0) {
+        return headRef.stdout.trim();
+    }
+    if (!allowDetached) {
+        throw new Error("Cannot run --fix-pr in detached HEAD state without --fix-pr-no-checkout.");
+    }
+    const rev = await runGit(cwd, ["rev-parse", "HEAD"]);
+    return rev.stdout.trim();
+}
+async function applyUpdatesInWorktree(rootCwd, worktreeCwd, updates) {
+    const manifestsByPath = new Map();
+    for (const update of updates) {
+        const relativePackagePath = path.relative(rootCwd, update.packagePath);
+        const targetPackagePath = path.resolve(worktreeCwd, relativePackagePath);
+        let manifest = manifestsByPath.get(targetPackagePath);
+        if (!manifest) {
+            manifest = await readManifest(targetPackagePath);
+            manifestsByPath.set(targetPackagePath, manifest);
+        }
+        const section = manifest[update.kind];
+        if (!section || !section[update.name])
+            continue;
+        section[update.name] = update.toRange;
+    }
+    for (const [manifestPath, manifest] of manifestsByPath) {
+        await writeManifest(manifestPath, manifest);
+    }
+}
+async function stageUpdatedManifests(rootCwd, worktreeCwd, updates) {
+    const files = Array.from(new Set(updates.map((update) => {
+        const relativePackagePath = path.relative(rootCwd, update.packagePath);
+        return path.resolve(worktreeCwd, relativePackagePath, "package.json");
+    }))).sort((a, b) => a.localeCompare(b));
+    if (files.length > 0) {
+        await runGit(worktreeCwd, ["add", "--", ...files]);
+    }
+}
+function renderCommitMessage(options, plan, totalBatches) {
+    const baseMessage = options.fixCommitMessage ?? `chore(deps): apply rainy-updates batch`;
+    return `${baseMessage} (${plan.index}/${totalBatches}, ${plan.updates.length} updates)`;
+}
+function sanitizeBranchToken(value) {
+    return value.replace(/^@/, "").replace(/[^a-zA-Z0-9._-]+/g, "-").replace(/^-+|-+$/g, "") || "batch";
+}
+async function runGit(cwd, args, allowNonZero = false) {
+    return await new Promise((resolve, reject) => {
+        const child = spawn("git", args, { cwd, stdio: ["ignore", "pipe", "pipe"] });
+        let stdout = "";
+        let stderr = "";
+        child.stdout.on("data", (chunk) => {
+            stdout += typeof chunk === "string" ? chunk : Buffer.from(chunk).toString("utf8");
+        });
+        child.stderr.on("data", (chunk) => {
+            stderr += typeof chunk === "string" ? chunk : Buffer.from(chunk).toString("utf8");
+        });
+        child.on("error", reject);
+        child.on("exit", (code) => {
+            const normalized = code ?? 1;
+            if (normalized !== 0 && !allowNonZero) {
+                reject(new Error(`git ${args.join(" ")} failed (${normalized}): ${stderr.trim()}`));
+                return;
+            }
+            resolve({ code: normalized, stdout, stderr });
+        });
+    });
+}

package/dist/core/options.js

@@ -41,6 +41,7 @@ export async function parseCliArgs(argv) {
         fixCommitMessage: undefined,
         fixDryRun: false,
         fixPrNoCheckout: false,
+        fixPrBatchSize: undefined,
         noPrReport: false,
         logLevel: "info",
         groupBy: "none",
@@ -220,6 +221,18 @@ export async function parseCliArgs(argv) {
             base.fixPrNoCheckout = true;
             continue;
         }
+        if (current === "--fix-pr-batch-size" && next) {
+            const parsed = Number(next);
+            if (!Number.isInteger(parsed) || parsed < 1) {
+                throw new Error("--fix-pr-batch-size must be a positive integer");
+            }
+            base.fixPrBatchSize = parsed;
+            index += 1;
+            continue;
+        }
+        if (current === "--fix-pr-batch-size") {
+            throw new Error("Missing value for --fix-pr-batch-size");
+        }
         if (current === "--log-level" && next) {
             base.logLevel = ensureLogLevel(next);
             index += 1;
@@ -485,6 +498,9 @@ function applyConfig(base, config) {
     if (typeof config.fixPrNoCheckout === "boolean") {
         base.fixPrNoCheckout = config.fixPrNoCheckout;
     }
+    if (typeof config.fixPrBatchSize === "number" && Number.isInteger(config.fixPrBatchSize) && config.fixPrBatchSize > 0) {
+        base.fixPrBatchSize = config.fixPrBatchSize;
+    }
     if (typeof config.noPrReport === "boolean") {
         base.noPrReport = config.noPrReport;
     }

package/dist/core/summary.js

@@ -33,6 +33,7 @@ export function createSummary(input) {
         fixPrApplied: false,
         fixBranchName: "",
         fixCommitSha: "",
+        fixPrBranchesCreated: 0,
         groupedUpdates: Math.max(0, Math.round(input.groupedUpdates ?? 0)),
         cooldownSkipped: Math.max(0, Math.round(input.cooldownSkipped ?? 0)),
         ciProfile: input.ciProfile ?? "minimal",

package/dist/output/format.js

@@ -36,6 +36,7 @@ export function renderResult(result, format) {
             `cooldown_skipped=${result.summary.cooldownSkipped}`,
             `ci_profile=${result.summary.ciProfile}`,
             `pr_limit_hit=${result.summary.prLimitHit ? "1" : "0"}`,
+            `fix_pr_branches_created=${result.summary.fixPrBranchesCreated}`,
         ].join("\n");
     }
     const lines = [];
@@ -78,6 +79,7 @@ export function renderResult(result, format) {
     lines.push(`Contract v${result.summary.contractVersion}, failReason=${result.summary.failReason}, duration=${result.summary.durationMs.total}ms`);
     if (result.summary.fixPrApplied) {
         lines.push(`Fix PR: applied on branch ${result.summary.fixBranchName ?? "unknown"} (${result.summary.fixCommitSha ?? "no-commit"})`);
+        lines.push(`Fix PR batches created: ${result.summary.fixPrBranchesCreated}`);
     }
     return lines.join("\n");
 }

package/dist/output/github.js

@@ -19,6 +19,7 @@ export async function writeGitHubOutput(filePath, result) {
         `ci_profile=${result.summary.ciProfile}`,
         `pr_limit_hit=${result.summary.prLimitHit === true ? "1" : "0"}`,
         `fix_pr_applied=${result.summary.fixPrApplied === true ? "1" : "0"}`,
+        `fix_pr_branches_created=${result.summary.fixPrBranchesCreated}`,
         `fix_pr_branch=${result.summary.fixBranchName ?? ""}`,
         `fix_pr_commit=${result.summary.fixCommitSha ?? ""}`,
     ];

package/dist/output/pr-report.js

@@ -11,6 +11,7 @@ export function renderPrReport(result) {
     lines.push(`- Cooldown skipped: ${result.summary.cooldownSkipped}`);
     lines.push(`- CI profile: ${result.summary.ciProfile}`);
     lines.push(`- PR limit hit: ${result.summary.prLimitHit ? "yes" : "no"}`);
+    lines.push(`- Fix PR branches created: ${result.summary.fixPrBranchesCreated}`);
     lines.push("");
     if (result.updates.length > 0) {
         lines.push("## Proposed Updates");

package/dist/output/sarif.js

@@ -73,6 +73,7 @@ export function createSarifReport(result) {
                     warningsCount: result.summary.warningCounts.total,
                     ciProfile: result.summary.ciProfile,
                     prLimitHit: result.summary.prLimitHit,
+                    fixPrBranchesCreated: result.summary.fixPrBranchesCreated,
                     durationMs: result.summary.durationMs,
                 },
             },

package/dist/types/index.d.ts

@@ -30,6 +30,7 @@ export interface RunOptions {
     fixCommitMessage?: string;
     fixDryRun?: boolean;
     fixPrNoCheckout?: boolean;
+    fixPrBatchSize?: number;
     noPrReport?: boolean;
     logLevel: LogLevel;
     groupBy: GroupBy;
@@ -100,6 +101,7 @@ export interface Summary {
     fixPrApplied: boolean;
     fixBranchName: string;
     fixCommitSha: string;
+    fixPrBranchesCreated: number;
     groupedUpdates: number;
     cooldownSkipped: number;
     ciProfile: CiProfile;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@rainy-updates/cli",
-  "version": "0.5.1-rc.1",
+  "version": "0.5.1-rc.2",
   "description": "Agentic CLI to check and upgrade npm/pnpm dependencies for CI workflows",
   "type": "module",
   "private": false,