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

package/CHANGELOG.md

@@ -2,6 +2,45 @@
 
 All notable changes to this project are documented in this file.
 
+## [0.5.0-rc.2] - 2026-02-27
+
+### Added
+
+- New fix-PR automation flags for CI branch workflows:
+  - `--fix-pr`
+  - `--fix-branch <name>`
+  - `--fix-commit-message <text>`
+  - `--fix-dry-run`
+  - `--no-pr-report`
+- New summary metadata for fix-PR execution:
+  - `fixPrApplied`
+  - `fixBranchName`
+  - `fixCommitSha`
+- New GitHub output values for fix-PR state:
+  - `fix_pr_applied`
+  - `fix_pr_branch`
+  - `fix_pr_commit`
+- Added command-specific help output for `check --help`.
+
+### Changed
+
+- `check --fix-pr` now executes update application flow to support branch+commit automation without requiring `upgrade`.
+- Default PR report path is auto-assigned when `--fix-pr` is enabled: `.artifacts/deps-report.md`.
+- CLI path-like options are resolved against the final effective `--cwd` value (stable behavior when option order varies).
+- Workspace discovery now supports recursive patterns (`**`) and negated patterns (`!pattern`) with safer directory traversal defaults.
+- Registry resolution now loads `.npmrc` scope mappings (`@scope:registry=...`) from user and project config.
+
+### Fixed
+
+- Prevented stale output contracts by writing fix-PR metadata into JSON/GitHub/SARIF artifact flow after git automation is resolved.
+
+### Tests
+
+- Added parser tests for fix-PR flags and final-cwd path resolution.
+- Added workspace discovery coverage for recursive and negated patterns.
+- Added fix-PR dry-run workflow test in temporary git repos.
+- Extended GitHub output tests for new fix-PR keys.
+
 ## [0.5.0-rc.1] - 2026-02-27
 
 ### Added

package/README.md

@@ -39,6 +39,9 @@ npx @rainy-updates/cli check --workspace --ci --format json --json-file .artifac
 # 3) Apply upgrades with workspace sync
 npx @rainy-updates/cli upgrade --target latest --workspace --sync --install
 
+# 3b) Generate a fix branch + commit for CI automation
+npx @rainy-updates/cli check --workspace --fix-pr --fix-branch chore/rainy-updates
+
 # 4) Warm cache for deterministic offline checks
 npx @rainy-updates/cli warm-cache --workspace --concurrency 32
 npx @rainy-updates/cli check --workspace --offline --ci
@@ -154,6 +157,11 @@ Schedule:
 - `--github-output <path>`
 - `--sarif-file <path>`
 - `--pr-report-file <path>`
+- `--fix-pr`
+- `--fix-branch <name>`
+- `--fix-commit-message <text>`
+- `--fix-dry-run`
+- `--no-pr-report`
 - `--ci`
 
 ### Upgrade-only
@@ -189,6 +197,7 @@ rainy-updates --version
 - Node.js 20+ runtime.
 - Works with npm and pnpm workflows.
 - Uses optional `undici` pool path for high-throughput HTTP.
+- Reads `.npmrc` default and scoped registries for private package environments.
 - Cache-first architecture for speed and resilience.
 
 ## CI/CD included

package/dist/bin/cli.js

@@ -9,6 +9,7 @@ import { upgrade } from "../core/upgrade.js";
 import { warmCache } from "../core/warm-cache.js";
 import { initCiWorkflow } from "../core/init-ci.js";
 import { diffBaseline, saveBaseline } from "../core/baseline.js";
+import { applyFixPr } from "../core/fix-pr.js";
 import { renderResult } from "../output/format.js";
 import { writeGitHubOutput } from "../output/github.js";
 import { createSarifReport } from "../output/sarif.js";
@@ -60,22 +61,22 @@ async function main() {
             process.exitCode = 1;
             return;
         }
-        const result = parsed.command === "upgrade"
-            ? await upgrade(parsed.options)
-            : parsed.command === "warm-cache"
-                ? await warmCache(parsed.options)
-                : await check(parsed.options);
-        const rendered = renderResult(result, parsed.options.format);
-        process.stdout.write(rendered + "\n");
-        if (parsed.options.jsonFile) {
-            await fs.mkdir(path.dirname(parsed.options.jsonFile), { recursive: true });
-            await fs.writeFile(parsed.options.jsonFile, JSON.stringify(result, null, 2) + "\n", "utf8");
-        }
+        const result = await runCommand(parsed);
         if (parsed.options.prReportFile) {
             const markdown = renderPrReport(result);
             await fs.mkdir(path.dirname(parsed.options.prReportFile), { recursive: true });
             await fs.writeFile(parsed.options.prReportFile, markdown + "\n", "utf8");
         }
+        if (parsed.options.fixPr && (parsed.command === "check" || parsed.command === "upgrade")) {
+            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;
+        }
+        if (parsed.options.jsonFile) {
+            await fs.mkdir(path.dirname(parsed.options.jsonFile), { recursive: true });
+            await fs.writeFile(parsed.options.jsonFile, JSON.stringify(result, null, 2) + "\n", "utf8");
+        }
         if (parsed.options.githubOutputFile) {
             await writeGitHubOutput(parsed.options.githubOutputFile, result);
         }
@@ -84,6 +85,8 @@ async function main() {
             await fs.mkdir(path.dirname(parsed.options.sarifFile), { recursive: true });
             await fs.writeFile(parsed.options.sarifFile, JSON.stringify(sarif, null, 2) + "\n", "utf8");
         }
+        const rendered = renderResult(result, parsed.options.format);
+        process.stdout.write(rendered + "\n");
         process.exitCode = resolveExitCode(result, parsed.options.failOn, parsed.options.maxUpdates, parsed.options.ci);
     }
     catch (error) {
@@ -94,6 +97,34 @@ async function main() {
 void main();
 function renderHelp(command) {
     const isCommand = command && !command.startsWith("-");
+    if (isCommand && command === "check") {
+        return `rainy-updates check [options]
+
+Detect available dependency updates.
+
+Options:
+  --workspace
+  --target patch|minor|major|latest
+  --filter <pattern>
+  --reject <pattern>
+  --dep-kinds deps,dev,optional,peer
+  --concurrency <n>
+  --cache-ttl <seconds>
+  --policy-file <path>
+  --offline
+  --fix-pr
+  --fix-branch <name>
+  --fix-commit-message <text>
+  --fix-dry-run
+  --no-pr-report
+  --json-file <path>
+  --github-output <path>
+  --sarif-file <path>
+  --pr-report-file <path>
+  --fail-on none|patch|minor|major|any
+  --max-updates <n>
+  --ci`;
+    }
     if (isCommand && command === "warm-cache") {
         return `rainy-updates warm-cache [options]
 
@@ -126,6 +157,11 @@ Options:
   --target patch|minor|major|latest
   --policy-file <path>
   --concurrency <n>
+  --fix-pr
+  --fix-branch <name>
+  --fix-commit-message <text>
+  --fix-dry-run
+  --no-pr-report
   --json-file <path>
   --pr-report-file <path>`;
     }
@@ -174,6 +210,11 @@ Global options:
   --policy-file <path>
   --fail-on none|patch|minor|major|any
   --max-updates <n>
+  --fix-pr
+  --fix-branch <name>
+  --fix-commit-message <text>
+  --fix-dry-run
+  --no-pr-report
   --concurrency <n>
   --cache-ttl <seconds>
   --offline
@@ -181,6 +222,24 @@ Global options:
   --help, -h
   --version, -v`;
 }
+async function runCommand(parsed) {
+    if (parsed.command === "upgrade") {
+        return await upgrade(parsed.options);
+    }
+    if (parsed.command === "warm-cache") {
+        return await warmCache(parsed.options);
+    }
+    if (parsed.options.fixPr) {
+        const upgradeOptions = {
+            ...parsed.options,
+            install: false,
+            packageManager: "auto",
+            sync: false,
+        };
+        return await upgrade(upgradeOptions);
+    }
+    return await check(parsed.options);
+}
 async function readPackageVersion() {
     const currentFile = fileURLToPath(import.meta.url);
     const packageJsonPath = path.resolve(path.dirname(currentFile), "../../package.json");

package/dist/config/loader.d.ts

@@ -17,6 +17,11 @@ export interface FileConfig {
     prReportFile?: string;
     failOn?: FailOnLevel;
     maxUpdates?: number;
+    fixPr?: boolean;
+    fixBranch?: string;
+    fixCommitMessage?: string;
+    fixDryRun?: boolean;
+    noPrReport?: boolean;
     install?: boolean;
     packageManager?: "auto" | "npm" | "pnpm";
     sync?: boolean;

package/dist/core/check.js

@@ -11,7 +11,7 @@ export async function check(options) {
     const packageManager = await detectPackageManager(options.cwd);
     const packageDirs = await discoverPackageDirs(options.cwd, options.workspace);
     const cache = await VersionCache.create();
-    const registryClient = new NpmRegistryClient();
+    const registryClient = new NpmRegistryClient(options.cwd);
     const policy = await loadPolicy(options.cwd, options.policyFile);
     const updates = [];
     const errors = [];

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

@@ -0,0 +1,7 @@
+import type { CheckResult, RunOptions } from "../types/index.js";
+export interface FixPrResult {
+    applied: boolean;
+    branchName?: string;
+    commitSha?: string;
+}
+export declare function applyFixPr(options: RunOptions, result: CheckResult, extraFiles: string[]): Promise<FixPrResult>;

package/dist/core/fix-pr.js

@@ -0,0 +1,68 @@
+import { spawn } from "node:child_process";
+import path from "node:path";
+export async function applyFixPr(options, result, extraFiles) {
+    if (!options.fixPr)
+        return { applied: false };
+    if (result.updates.length === 0)
+        return { applied: false };
+    const status = await runGit(options.cwd, ["status", "--porcelain"]);
+    if (status.stdout.trim().length > 0) {
+        throw new Error("Cannot run --fix-pr with a dirty git working tree.");
+    }
+    const branch = options.fixBranch ?? "chore/rainy-updates";
+    const branchCheck = await runGit(options.cwd, ["rev-parse", "--verify", "--quiet", branch], true);
+    if (branchCheck.code === 0) {
+        await runGit(options.cwd, ["checkout", branch]);
+    }
+    else {
+        await runGit(options.cwd, ["checkout", "-b", branch]);
+    }
+    if (options.fixDryRun) {
+        return {
+            applied: false,
+            branchName: branch,
+        };
+    }
+    const manifestFiles = Array.from(new Set(result.packagePaths.map((pkgPath) => path.join(pkgPath, "package.json"))));
+    const filesToStage = Array.from(new Set([...manifestFiles, ...extraFiles]));
+    if (filesToStage.length > 0) {
+        await runGit(options.cwd, ["add", "--", ...filesToStage]);
+    }
+    const stagedCheck = await runGit(options.cwd, ["diff", "--cached", "--quiet"], true);
+    if (stagedCheck.code === 0) {
+        return {
+            applied: false,
+            branchName: branch,
+        };
+    }
+    const message = options.fixCommitMessage ?? `chore(deps): apply rainy-updates (${result.updates.length} updates)`;
+    await runGit(options.cwd, ["commit", "-m", message]);
+    const rev = await runGit(options.cwd, ["rev-parse", "HEAD"]);
+    return {
+        applied: true,
+        branchName: branch,
+        commitSha: rev.stdout.trim(),
+    };
+}
+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

@@ -36,12 +36,22 @@ export async function parseCliArgs(argv) {
         prReportFile: undefined,
         failOn: "none",
         maxUpdates: undefined,
+        fixPr: false,
+        fixBranch: "chore/rainy-updates",
+        fixCommitMessage: undefined,
+        fixDryRun: false,
+        noPrReport: false,
     };
     let force = false;
     let initCiMode = "enterprise";
     let initCiSchedule = "weekly";
     let baselineAction = "check";
     let baselineFilePath = path.resolve(base.cwd, ".rainy-updates-baseline.json");
+    let jsonFileRaw;
+    let githubOutputRaw;
+    let sarifFileRaw;
+    let policyFileRaw;
+    let prReportFileRaw;
     let resolvedConfig = await loadConfig(base.cwd);
     applyConfig(base, resolvedConfig);
     for (let index = 0; index < args.length; index += 1) {
@@ -111,7 +121,7 @@ export async function parseCliArgs(argv) {
             continue;
         }
         if (current === "--json-file" && next) {
-            base.jsonFile = path.resolve(next);
+            jsonFileRaw = next;
             index += 1;
             continue;
         }
@@ -119,7 +129,7 @@ export async function parseCliArgs(argv) {
             throw new Error("Missing value for --json-file");
         }
         if (current === "--github-output" && next) {
-            base.githubOutputFile = path.resolve(next);
+            githubOutputRaw = next;
             index += 1;
             continue;
         }
@@ -127,7 +137,7 @@ export async function parseCliArgs(argv) {
             throw new Error("Missing value for --github-output");
         }
         if (current === "--sarif-file" && next) {
-            base.sarifFile = path.resolve(next);
+            sarifFileRaw = next;
             index += 1;
             continue;
         }
@@ -151,7 +161,7 @@ export async function parseCliArgs(argv) {
             continue;
         }
         if (current === "--policy-file" && next) {
-            base.policyFile = path.resolve(next);
+            policyFileRaw = next;
             index += 1;
             continue;
         }
@@ -159,7 +169,7 @@ export async function parseCliArgs(argv) {
             throw new Error("Missing value for --policy-file");
         }
         if (current === "--pr-report-file" && next) {
-            base.prReportFile = path.resolve(next);
+            prReportFileRaw = next;
             index += 1;
             continue;
         }
@@ -170,6 +180,34 @@ export async function parseCliArgs(argv) {
             force = true;
             continue;
         }
+        if (current === "--fix-pr") {
+            base.fixPr = true;
+            continue;
+        }
+        if (current === "--fix-branch" && next) {
+            base.fixBranch = next;
+            index += 1;
+            continue;
+        }
+        if (current === "--fix-branch") {
+            throw new Error("Missing value for --fix-branch");
+        }
+        if (current === "--fix-commit-message" && next) {
+            base.fixCommitMessage = next;
+            index += 1;
+            continue;
+        }
+        if (current === "--fix-commit-message") {
+            throw new Error("Missing value for --fix-commit-message");
+        }
+        if (current === "--fix-dry-run") {
+            base.fixDryRun = true;
+            continue;
+        }
+        if (current === "--no-pr-report") {
+            base.noPrReport = true;
+            continue;
+        }
         if (current === "--install" && command === "upgrade") {
             continue;
         }
@@ -249,6 +287,27 @@ export async function parseCliArgs(argv) {
         }
         throw new Error(`Unexpected argument: ${current}`);
     }
+    if (jsonFileRaw) {
+        base.jsonFile = path.resolve(base.cwd, jsonFileRaw);
+    }
+    if (githubOutputRaw) {
+        base.githubOutputFile = path.resolve(base.cwd, githubOutputRaw);
+    }
+    if (sarifFileRaw) {
+        base.sarifFile = path.resolve(base.cwd, sarifFileRaw);
+    }
+    if (policyFileRaw) {
+        base.policyFile = path.resolve(base.cwd, policyFileRaw);
+    }
+    if (prReportFileRaw) {
+        base.prReportFile = path.resolve(base.cwd, prReportFileRaw);
+    }
+    if (base.noPrReport) {
+        base.prReportFile = undefined;
+    }
+    else if (base.fixPr && !base.prReportFile) {
+        base.prReportFile = path.resolve(base.cwd, ".artifacts/deps-report.md");
+    }
     if (command === "upgrade") {
         const configPm = resolvedConfig.packageManager;
         const cliPm = parsePackageManager(args);
@@ -335,6 +394,21 @@ function applyConfig(base, config) {
     if (typeof config.maxUpdates === "number" && Number.isInteger(config.maxUpdates) && config.maxUpdates >= 0) {
         base.maxUpdates = config.maxUpdates;
     }
+    if (typeof config.fixPr === "boolean") {
+        base.fixPr = config.fixPr;
+    }
+    if (typeof config.fixBranch === "string" && config.fixBranch.length > 0) {
+        base.fixBranch = config.fixBranch;
+    }
+    if (typeof config.fixCommitMessage === "string" && config.fixCommitMessage.length > 0) {
+        base.fixCommitMessage = config.fixCommitMessage;
+    }
+    if (typeof config.fixDryRun === "boolean") {
+        base.fixDryRun = config.fixDryRun;
+    }
+    if (typeof config.noPrReport === "boolean") {
+        base.noPrReport = config.noPrReport;
+    }
 }
 function parsePackageManager(args) {
     const index = args.indexOf("--pm");

package/dist/core/warm-cache.js

@@ -8,7 +8,7 @@ export async function warmCache(options) {
     const packageManager = await detectPackageManager(options.cwd);
     const packageDirs = await discoverPackageDirs(options.cwd, options.workspace);
     const cache = await VersionCache.create();
-    const registryClient = new NpmRegistryClient();
+    const registryClient = new NpmRegistryClient(options.cwd);
     const errors = [];
     const warnings = [];
     let totalDependencies = 0;

package/dist/output/format.js

@@ -52,5 +52,8 @@ export function renderResult(result, format) {
     }
     lines.push("");
     lines.push(`Summary: ${result.summary.updatesFound} updates, ${result.summary.checkedDependencies}/${result.summary.totalDependencies} checked, ${result.summary.warmedPackages} warmed`);
+    if (result.summary.fixPrApplied) {
+        lines.push(`Fix PR: applied on branch ${result.summary.fixBranchName ?? "unknown"} (${result.summary.fixCommitSha ?? "no-commit"})`);
+    }
     return lines.join("\n");
 }

package/dist/output/github.js

@@ -8,6 +8,9 @@ export async function writeGitHubOutput(filePath, result) {
         `checked_dependencies=${result.summary.checkedDependencies}`,
         `scanned_packages=${result.summary.scannedPackages}`,
         `warmed_packages=${result.summary.warmedPackages}`,
+        `fix_pr_applied=${result.summary.fixPrApplied === true ? "1" : "0"}`,
+        `fix_pr_branch=${result.summary.fixBranchName ?? ""}`,
+        `fix_pr_commit=${result.summary.fixCommitSha ?? ""}`,
     ];
     await fs.mkdir(path.dirname(filePath), { recursive: true });
     await fs.writeFile(filePath, lines.join("\n") + "\n", "utf8");

package/dist/registry/npm.d.ts

@@ -11,7 +11,7 @@ export interface ResolveManyResult {
 }
 export declare class NpmRegistryClient {
     private readonly requesterPromise;
-    constructor();
+    constructor(cwd?: string);
     resolvePackageMetadata(packageName: string, timeoutMs?: number): Promise<{
         latestVersion: string | null;
         versions: string[];

package/dist/registry/npm.js

@@ -1,10 +1,15 @@
+import { promises as fs } from "node:fs";
+import os from "node:os";
+import path from "node:path";
+import process from "node:process";
 import { asyncPool } from "../utils/async-pool.js";
 const DEFAULT_TIMEOUT_MS = 8000;
 const USER_AGENT = "@rainy-updates/cli";
+const DEFAULT_REGISTRY = "https://registry.npmjs.org/";
 export class NpmRegistryClient {
     requesterPromise;
-    constructor() {
-        this.requesterPromise = createRequester();
+    constructor(cwd) {
+        this.requesterPromise = createRequester(cwd);
     }
     async resolvePackageMetadata(packageName, timeoutMs = DEFAULT_TIMEOUT_MS) {
         const requester = await this.requesterPromise;
@@ -79,15 +84,18 @@ export class NpmRegistryClient {
 function sleep(ms) {
     return new Promise((resolve) => setTimeout(resolve, ms));
 }
-async function createRequester() {
-    const undiciRequester = await tryCreateUndiciRequester();
+async function createRequester(cwd) {
+    const registryConfig = await loadRegistryConfig(cwd ?? process.cwd());
+    const undiciRequester = await tryCreateUndiciRequester(registryConfig);
     if (undiciRequester)
         return undiciRequester;
     return async (packageName, timeoutMs) => {
         const controller = new AbortController();
         const timeout = setTimeout(() => controller.abort(), timeoutMs);
+        const registry = resolveRegistryForPackage(packageName, registryConfig);
+        const url = buildRegistryUrl(registry, packageName);
         try {
-            const response = await fetch(`https://registry.npmjs.org/${encodeURIComponent(packageName)}`, {
+            const response = await fetch(url, {
                 headers: {
                     accept: "application/json",
                     "user-agent": USER_AGENT,
@@ -102,21 +110,17 @@ async function createRequester() {
         }
     };
 }
-async function tryCreateUndiciRequester() {
+async function tryCreateUndiciRequester(registryConfig) {
     try {
         const dynamicImport = Function("specifier", "return import(specifier)");
         const undici = await dynamicImport("undici");
-        const pool = new undici.Pool("https://registry.npmjs.org", {
-            connections: 20,
-            pipelining: 10,
-            allowH2: true,
-        });
         return async (packageName, timeoutMs) => {
             const controller = new AbortController();
             const timeout = setTimeout(() => controller.abort(), timeoutMs);
+            const registry = resolveRegistryForPackage(packageName, registryConfig);
+            const url = buildRegistryUrl(registry, packageName);
             try {
-                const res = await pool.request({
-                    path: `/${encodeURIComponent(packageName)}`,
+                const res = await undici.request(url, {
                     method: "GET",
                     headers: {
                         accept: "application/json",
@@ -143,3 +147,74 @@ async function tryCreateUndiciRequester() {
         return null;
     }
 }
+async function loadRegistryConfig(cwd) {
+    const homeNpmrc = path.join(os.homedir(), ".npmrc");
+    const projectNpmrc = path.join(cwd, ".npmrc");
+    const merged = new Map();
+    for (const filePath of [homeNpmrc, projectNpmrc]) {
+        try {
+            const content = await fs.readFile(filePath, "utf8");
+            const parsed = parseNpmrc(content);
+            for (const [key, value] of parsed) {
+                merged.set(key, value);
+            }
+        }
+        catch {
+            // ignore missing/unreadable file
+        }
+    }
+    const defaultRegistry = normalizeRegistryUrl(merged.get("registry") ?? DEFAULT_REGISTRY);
+    const scopedRegistries = new Map();
+    for (const [key, value] of merged) {
+        if (!key.startsWith("@") || !key.endsWith(":registry"))
+            continue;
+        const scope = key.slice(0, key.indexOf(":registry"));
+        if (scope.length > 1) {
+            scopedRegistries.set(scope, normalizeRegistryUrl(value));
+        }
+    }
+    return { defaultRegistry, scopedRegistries };
+}
+function parseNpmrc(content) {
+    const values = new Map();
+    const lines = content.split(/\r?\n/);
+    for (const line of lines) {
+        const trimmed = line.trim();
+        if (trimmed.length === 0 || trimmed.startsWith("#") || trimmed.startsWith(";"))
+            continue;
+        const separator = trimmed.indexOf("=");
+        if (separator <= 0)
+            continue;
+        const key = trimmed.slice(0, separator).trim();
+        const value = trimmed.slice(separator + 1).trim();
+        if (key.length > 0 && value.length > 0) {
+            values.set(key, value);
+        }
+    }
+    return values;
+}
+function normalizeRegistryUrl(value) {
+    const normalized = value.endsWith("/") ? value : `${value}/`;
+    return normalized;
+}
+function resolveRegistryForPackage(packageName, config) {
+    const scope = extractScope(packageName);
+    if (scope) {
+        const scoped = config.scopedRegistries.get(scope);
+        if (scoped)
+            return scoped;
+    }
+    return config.defaultRegistry;
+}
+function extractScope(packageName) {
+    if (!packageName.startsWith("@"))
+        return null;
+    const firstSlash = packageName.indexOf("/");
+    if (firstSlash <= 1)
+        return null;
+    return packageName.slice(0, firstSlash);
+}
+function buildRegistryUrl(registry, packageName) {
+    const base = normalizeRegistryUrl(registry);
+    return new URL(encodeURIComponent(packageName), base).toString();
+}

package/dist/types/index.d.ts

@@ -21,6 +21,11 @@ export interface RunOptions {
     prReportFile?: string;
     failOn?: FailOnLevel;
     maxUpdates?: number;
+    fixPr?: boolean;
+    fixBranch?: string;
+    fixCommitMessage?: string;
+    fixDryRun?: boolean;
+    noPrReport?: boolean;
 }
 export interface CheckOptions extends RunOptions {
 }
@@ -60,6 +65,9 @@ export interface Summary {
     upgraded: number;
     skipped: number;
     warmedPackages: number;
+    fixPrApplied?: boolean;
+    fixBranchName?: string;
+    fixCommitSha?: string;
 }
 export interface CheckResult {
     projectPath: string;

package/dist/workspace/discover.js

@@ -5,14 +5,21 @@ export async function discoverPackageDirs(cwd, workspaceMode) {
         return [cwd];
     }
     const roots = new Set([cwd]);
-    const packagePatterns = await readPackageJsonWorkspacePatterns(cwd);
-    const pnpmPatterns = await readPnpmWorkspacePatterns(cwd);
-    for (const pattern of [...packagePatterns, ...pnpmPatterns]) {
-        const dirs = await expandSingleLevelPattern(cwd, pattern);
+    const patterns = [...(await readPackageJsonWorkspacePatterns(cwd)), ...(await readPnpmWorkspacePatterns(cwd))];
+    const include = patterns.filter((item) => !item.startsWith("!"));
+    const exclude = patterns.filter((item) => item.startsWith("!")).map((item) => item.slice(1));
+    for (const pattern of include) {
+        const dirs = await expandWorkspacePattern(cwd, pattern);
         for (const dir of dirs) {
             roots.add(dir);
         }
     }
+    for (const pattern of exclude) {
+        const dirs = await expandWorkspacePattern(cwd, pattern);
+        for (const dir of dirs) {
+            roots.delete(dir);
+        }
+    }
     const existing = [];
     for (const dir of roots) {
         const packageJsonPath = path.join(dir, "package.json");
@@ -21,7 +28,7 @@ export async function discoverPackageDirs(cwd, workspaceMode) {
             existing.push(dir);
         }
         catch {
-            // ignore
+            // ignore missing package.json
         }
     }
     return existing.sort();
@@ -53,7 +60,7 @@ async function readPnpmWorkspacePatterns(cwd) {
             const trimmed = line.trim();
             if (!trimmed.startsWith("-"))
                 continue;
-            const value = trimmed.replace(/^-\s*/, "").replace(/^['\"]|['\"]$/g, "");
+            const value = trimmed.replace(/^-\s*/, "").replace(/^['"]|['"]$/g, "");
             if (value.length > 0) {
                 patterns.push(value);
             }
@@ -64,23 +71,48 @@ async function readPnpmWorkspacePatterns(cwd) {
         return [];
     }
 }
-async function expandSingleLevelPattern(cwd, pattern) {
-    if (!pattern.includes("*")) {
-        return [path.resolve(cwd, pattern)];
-    }
-    const normalized = pattern.replace(/\\/g, "/");
-    const starIndex = normalized.indexOf("*");
-    const basePart = normalized.slice(0, starIndex).replace(/\/$/, "");
-    const suffix = normalized.slice(starIndex + 1);
-    if (suffix.length > 0 && suffix !== "/") {
+async function expandWorkspacePattern(cwd, pattern) {
+    const normalized = pattern.replace(/\\/g, "/").replace(/^\.\//, "").replace(/\/+$/, "");
+    if (normalized.length === 0)
         return [];
+    if (!normalized.includes("*")) {
+        return [path.resolve(cwd, normalized)];
+    }
+    const segments = normalized.split("/").filter(Boolean);
+    const results = new Set();
+    await collectMatches(path.resolve(cwd), segments, 0, results);
+    return Array.from(results);
+}
+async function collectMatches(baseDir, segments, index, out) {
+    if (index >= segments.length) {
+        out.add(baseDir);
+        return;
     }
-    const baseDir = path.resolve(cwd, basePart);
+    const segment = segments[index];
+    if (segment === "**") {
+        await collectMatches(baseDir, segments, index + 1, out);
+        const children = await readChildDirs(baseDir);
+        for (const child of children) {
+            await collectMatches(child, segments, index, out);
+        }
+        return;
+    }
+    if (segment === "*") {
+        const children = await readChildDirs(baseDir);
+        for (const child of children) {
+            await collectMatches(child, segments, index + 1, out);
+        }
+        return;
+    }
+    await collectMatches(path.join(baseDir, segment), segments, index + 1, out);
+}
+async function readChildDirs(dir) {
     try {
-        const entries = await fs.readdir(baseDir, { withFileTypes: true });
+        const entries = await fs.readdir(dir, { withFileTypes: true });
         return entries
             .filter((entry) => entry.isDirectory())
-            .map((entry) => path.join(baseDir, entry.name));
+            .filter((entry) => entry.name !== "node_modules" && !entry.name.startsWith("."))
+            .map((entry) => path.join(dir, entry.name));
     }
     catch {
         return [];

package/package.json

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