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

package/dist/core/check.js

@@ -1,7 +1,7 @@
 import path from "node:path";
 import { collectDependencies, readManifest } from "../parsers/package-json.js";
 import { matchesPattern } from "../utils/pattern.js";
-import { applyRangeStyle, classifyDiff, clampTarget, pickTargetVersion } from "../utils/semver.js";
+import { applyRangeStyle, classifyDiff, clampTarget, pickTargetVersionFromAvailable } from "../utils/semver.js";
 import { VersionCache } from "../cache/cache.js";
 import { NpmRegistryClient } from "../registry/npm.js";
 import { detectPackageManager } from "../pm/detect.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 = [];
@@ -53,7 +53,10 @@ export async function check(options) {
     for (const packageName of uniquePackageNames) {
         const cached = await cache.getValid(packageName, options.target);
         if (cached) {
-            resolvedVersions.set(packageName, cached.latestVersion);
+            resolvedVersions.set(packageName, {
+                latestVersion: cached.latestVersion,
+                availableVersions: cached.availableVersions,
+            });
         }
         else {
             unresolvedPackages.push(packageName);
@@ -64,7 +67,10 @@ export async function check(options) {
             for (const packageName of unresolvedPackages) {
                 const stale = await cache.getAny(packageName, options.target);
                 if (stale) {
-                    resolvedVersions.set(packageName, stale.latestVersion);
+                    resolvedVersions.set(packageName, {
+                        latestVersion: stale.latestVersion,
+                        availableVersions: stale.availableVersions,
+                    });
                     warnings.push(`Using stale cache for ${packageName} because --offline is enabled.`);
                 }
                 else {
@@ -73,19 +79,25 @@ export async function check(options) {
             }
         }
         else {
-            const fetched = await registryClient.resolveManyLatestVersions(unresolvedPackages, {
+            const fetched = await registryClient.resolveManyPackageMetadata(unresolvedPackages, {
                 concurrency: options.concurrency,
             });
-            for (const [packageName, version] of fetched.versions) {
-                resolvedVersions.set(packageName, version);
-                if (version) {
-                    await cache.set(packageName, options.target, version, options.cacheTtlSeconds);
+            for (const [packageName, metadata] of fetched.metadata) {
+                resolvedVersions.set(packageName, {
+                    latestVersion: metadata.latestVersion,
+                    availableVersions: metadata.versions,
+                });
+                if (metadata.latestVersion) {
+                    await cache.set(packageName, options.target, metadata.latestVersion, metadata.versions, options.cacheTtlSeconds);
                 }
             }
             for (const [packageName, error] of fetched.errors) {
                 const stale = await cache.getAny(packageName, options.target);
                 if (stale) {
-                    resolvedVersions.set(packageName, stale.latestVersion);
+                    resolvedVersions.set(packageName, {
+                        latestVersion: stale.latestVersion,
+                        availableVersions: stale.availableVersions,
+                    });
                     warnings.push(`Using stale cache for ${packageName} due to registry error: ${error}`);
                 }
                 else {
@@ -95,12 +107,12 @@ export async function check(options) {
         }
     }
     for (const task of tasks) {
-        const latestVersion = resolvedVersions.get(task.dependency.name);
-        if (!latestVersion)
+        const metadata = resolvedVersions.get(task.dependency.name);
+        if (!metadata?.latestVersion)
             continue;
         const rule = policy.packageRules.get(task.dependency.name);
         const effectiveTarget = clampTarget(options.target, rule?.maxTarget);
-        const picked = pickTargetVersion(task.dependency.range, latestVersion, effectiveTarget);
+        const picked = pickTargetVersionFromAvailable(task.dependency.range, metadata.availableVersions, metadata.latestVersion, effectiveTarget);
         if (!picked)
             continue;
         const nextRange = applyRangeStyle(task.dependency.range, picked);

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/init-ci.d.ts

@@ -1,4 +1,4 @@
-export type InitCiMode = "minimal" | "strict";
+export type InitCiMode = "minimal" | "strict" | "enterprise";
 export type InitCiSchedule = "weekly" | "daily" | "off";
 export interface InitCiOptions {
     mode: InitCiMode;

package/dist/core/init-ci.js

@@ -15,7 +15,9 @@ export async function initCiWorkflow(cwd, force, options) {
     const scheduleBlock = renderScheduleBlock(options.schedule);
     const workflow = options.mode === "minimal"
         ? minimalWorkflowTemplate(scheduleBlock, packageManager)
-        : strictWorkflowTemplate(scheduleBlock, packageManager);
+        : options.mode === "strict"
+            ? strictWorkflowTemplate(scheduleBlock, packageManager)
+            : enterpriseWorkflowTemplate(scheduleBlock, packageManager);
     await mkdir(path.dirname(workflowPath), { recursive: true });
     await writeFile(workflowPath, workflow, "utf8");
     return { path: workflowPath, created: true };
@@ -49,3 +51,9 @@ function minimalWorkflowTemplate(scheduleBlock, packageManager) {
 function strictWorkflowTemplate(scheduleBlock, packageManager) {
     return `name: Rainy Updates\n\non:\n${scheduleBlock}\n\npermissions:\n  contents: read\n  security-events: write\n\njobs:\n  dependency-check:\n    runs-on: ubuntu-latest\n    steps:\n      - name: Checkout\n        uses: actions/checkout@v4\n\n      - name: Setup Node\n        uses: actions/setup-node@v4\n        with:\n          node-version: '20'\n\n${installStep(packageManager)}\n\n      - name: Warm cache\n        run: npx @rainy-updates/cli warm-cache --workspace --concurrency 32\n\n      - name: Run strict dependency check\n        run: |\n          npx @rainy-updates/cli check \\\n            --workspace \\\n            --offline \\\n            --ci \\\n            --concurrency 32 \\\n            --format github \\\n            --json-file .artifacts/deps-report.json \\\n            --pr-report-file .artifacts/deps-report.md \\\n            --sarif-file .artifacts/deps-report.sarif \\\n            --github-output $GITHUB_OUTPUT\n\n      - name: Upload report artifacts\n        uses: actions/upload-artifact@v4\n        with:\n          name: rainy-updates-report\n          path: .artifacts/\n\n      - name: Upload SARIF\n        uses: github/codeql-action/upload-sarif@v3\n        with:\n          sarif_file: .artifacts/deps-report.sarif\n`;
 }
+function enterpriseWorkflowTemplate(scheduleBlock, packageManager) {
+    const detectedPmInstall = packageManager === "pnpm"
+        ? "corepack enable && corepack prepare pnpm@9 --activate && pnpm install --frozen-lockfile"
+        : "npm ci";
+    return `name: Rainy Updates Enterprise\n\non:\n${scheduleBlock}\n\npermissions:\n  contents: read\n  security-events: write\n  actions: read\n\nconcurrency:\n  group: rainy-updates-\${{ github.ref }}\n  cancel-in-progress: false\n\njobs:\n  dependency-check:\n    runs-on: ubuntu-latest\n    strategy:\n      fail-fast: false\n      matrix:\n        node: [20, 22]\n    steps:\n      - name: Checkout\n        uses: actions/checkout@v4\n\n      - name: Setup Node\n        uses: actions/setup-node@v4\n        with:\n          node-version: \${{ matrix.node }}\n\n      - name: Install dependencies\n        run: ${detectedPmInstall}\n\n      - name: Warm cache\n        run: npx @rainy-updates/cli warm-cache --workspace --concurrency 32\n\n      - name: Check updates with rollout controls\n        run: |\n          npx @rainy-updates/cli check \\\n            --workspace \\\n            --offline \\\n            --concurrency 32 \\\n            --format github \\\n            --fail-on minor \\\n            --max-updates 50 \\\n            --json-file .artifacts/deps-report-node-\${{ matrix.node }}.json \\\n            --pr-report-file .artifacts/deps-report-node-\${{ matrix.node }}.md \\\n            --sarif-file .artifacts/deps-report-node-\${{ matrix.node }}.sarif \\\n            --github-output $GITHUB_OUTPUT\n\n      - name: Upload report artifacts\n        uses: actions/upload-artifact@v4\n        with:\n          name: rainy-updates-report-node-\${{ matrix.node }}\n          path: .artifacts/\n          retention-days: 14\n\n      - name: Upload SARIF\n        uses: github/codeql-action/upload-sarif@v3\n        with:\n          sarif_file: .artifacts/deps-report-node-\${{ matrix.node }}.sarif\n`;
+}

package/dist/core/options.d.ts

@@ -1,4 +1,4 @@
-import type { CheckOptions, UpgradeOptions } from "../types/index.js";
+import type { BaselineOptions, CheckOptions, UpgradeOptions } from "../types/index.js";
 import type { InitCiMode, InitCiSchedule } from "./init-ci.js";
 export type ParsedCliArgs = {
     command: "check";
@@ -17,5 +17,10 @@ export type ParsedCliArgs = {
         mode: InitCiMode;
         schedule: InitCiSchedule;
     };
+} | {
+    command: "baseline";
+    options: BaselineOptions & {
+        action: "save" | "check";
+    };
 };
 export declare function parseCliArgs(argv: string[]): Promise<ParsedCliArgs>;

package/dist/core/options.js

@@ -7,7 +7,7 @@ const DEFAULT_INCLUDE_KINDS = [
     "optionalDependencies",
     "peerDependencies",
 ];
-const KNOWN_COMMANDS = ["check", "upgrade", "warm-cache", "init-ci"];
+const KNOWN_COMMANDS = ["check", "upgrade", "warm-cache", "init-ci", "baseline"];
 export async function parseCliArgs(argv) {
     const firstArg = argv[0];
     const isKnownCommand = KNOWN_COMMANDS.includes(firstArg);
@@ -34,10 +34,24 @@ export async function parseCliArgs(argv) {
         offline: false,
         policyFile: undefined,
         prReportFile: undefined,
+        failOn: "none",
+        maxUpdates: undefined,
+        fixPr: false,
+        fixBranch: "chore/rainy-updates",
+        fixCommitMessage: undefined,
+        fixDryRun: false,
+        noPrReport: false,
     };
     let force = false;
-    let initCiMode = "strict";
+    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) {
@@ -48,23 +62,36 @@ export async function parseCliArgs(argv) {
             index += 1;
             continue;
         }
+        if (current === "--target") {
+            throw new Error("Missing value for --target");
+        }
         if (current === "--filter" && next) {
             base.filter = next;
             index += 1;
             continue;
         }
+        if (current === "--filter") {
+            throw new Error("Missing value for --filter");
+        }
         if (current === "--reject" && next) {
             base.reject = next;
             index += 1;
             continue;
         }
+        if (current === "--reject") {
+            throw new Error("Missing value for --reject");
+        }
         if (current === "--cwd" && next) {
             base.cwd = path.resolve(next);
             resolvedConfig = await loadConfig(base.cwd);
             applyConfig(base, resolvedConfig);
+            baselineFilePath = path.resolve(base.cwd, ".rainy-updates-baseline.json");
             index += 1;
             continue;
         }
+        if (current === "--cwd") {
+            throw new Error("Missing value for --cwd");
+        }
         if (current === "--cache-ttl" && next) {
             const parsed = Number(next);
             if (!Number.isFinite(parsed) || parsed < 0) {
@@ -74,11 +101,17 @@ export async function parseCliArgs(argv) {
             index += 1;
             continue;
         }
+        if (current === "--cache-ttl") {
+            throw new Error("Missing value for --cache-ttl");
+        }
         if (current === "--format" && next) {
             base.format = ensureFormat(next);
             index += 1;
             continue;
         }
+        if (current === "--format") {
+            throw new Error("Missing value for --format");
+        }
         if (current === "--ci") {
             base.ci = true;
             continue;
@@ -88,20 +121,29 @@ export async function parseCliArgs(argv) {
             continue;
         }
         if (current === "--json-file" && next) {
-            base.jsonFile = path.resolve(next);
+            jsonFileRaw = next;
             index += 1;
             continue;
         }
+        if (current === "--json-file") {
+            throw new Error("Missing value for --json-file");
+        }
         if (current === "--github-output" && next) {
-            base.githubOutputFile = path.resolve(next);
+            githubOutputRaw = next;
             index += 1;
             continue;
         }
+        if (current === "--github-output") {
+            throw new Error("Missing value for --github-output");
+        }
         if (current === "--sarif-file" && next) {
-            base.sarifFile = path.resolve(next);
+            sarifFileRaw = next;
             index += 1;
             continue;
         }
+        if (current === "--sarif-file") {
+            throw new Error("Missing value for --sarif-file");
+        }
         if (current === "--concurrency" && next) {
             const parsed = Number(next);
             if (!Number.isInteger(parsed) || parsed <= 0) {
@@ -111,39 +153,160 @@ export async function parseCliArgs(argv) {
             index += 1;
             continue;
         }
+        if (current === "--concurrency") {
+            throw new Error("Missing value for --concurrency");
+        }
         if (current === "--offline") {
             base.offline = true;
             continue;
         }
         if (current === "--policy-file" && next) {
-            base.policyFile = path.resolve(next);
+            policyFileRaw = next;
             index += 1;
             continue;
         }
+        if (current === "--policy-file") {
+            throw new Error("Missing value for --policy-file");
+        }
         if (current === "--pr-report-file" && next) {
-            base.prReportFile = path.resolve(next);
+            prReportFileRaw = next;
             index += 1;
             continue;
         }
+        if (current === "--pr-report-file") {
+            throw new Error("Missing value for --pr-report-file");
+        }
         if (current === "--force") {
             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;
+        }
+        if (current === "--sync" && command === "upgrade") {
+            continue;
+        }
+        if (current === "--pm" && next && command === "upgrade") {
+            parsePackageManager(args);
+            index += 1;
+            continue;
+        }
+        if (current === "--pm" && command === "upgrade") {
+            throw new Error("Missing value for --pm");
+        }
         if (current === "--mode" && next) {
             initCiMode = ensureInitCiMode(next);
             index += 1;
             continue;
         }
+        if (current === "--mode") {
+            throw new Error("Missing value for --mode");
+        }
         if (current === "--schedule" && next) {
             initCiSchedule = ensureInitCiSchedule(next);
             index += 1;
             continue;
         }
+        if (current === "--schedule") {
+            throw new Error("Missing value for --schedule");
+        }
         if (current === "--dep-kinds" && next) {
             base.includeKinds = parseDependencyKinds(next);
             index += 1;
             continue;
         }
+        if (current === "--dep-kinds") {
+            throw new Error("Missing value for --dep-kinds");
+        }
+        if (current === "--fail-on" && next) {
+            base.failOn = ensureFailOn(next);
+            index += 1;
+            continue;
+        }
+        if (current === "--fail-on") {
+            throw new Error("Missing value for --fail-on");
+        }
+        if (current === "--max-updates" && next) {
+            const parsed = Number(next);
+            if (!Number.isInteger(parsed) || parsed < 0) {
+                throw new Error("--max-updates must be a non-negative integer");
+            }
+            base.maxUpdates = parsed;
+            index += 1;
+            continue;
+        }
+        if (current === "--max-updates") {
+            throw new Error("Missing value for --max-updates");
+        }
+        if (current === "--save") {
+            baselineAction = "save";
+            continue;
+        }
+        if (current === "--check") {
+            baselineAction = "check";
+            continue;
+        }
+        if (current === "--file" && next) {
+            baselineFilePath = path.resolve(base.cwd, next);
+            index += 1;
+            continue;
+        }
+        if (current === "--file") {
+            throw new Error("Missing value for --file");
+        }
+        if (current.startsWith("-")) {
+            throw new Error(`Unknown option: ${current}`);
+        }
+        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;
@@ -170,6 +333,19 @@ export async function parseCliArgs(argv) {
             },
         };
     }
+    if (command === "baseline") {
+        return {
+            command,
+            options: {
+                action: baselineAction,
+                cwd: base.cwd,
+                workspace: base.workspace,
+                includeKinds: base.includeKinds,
+                filePath: baselineFilePath,
+                ci: base.ci,
+            },
+        };
+    }
     return {
         command: "check",
         options: base,
@@ -212,6 +388,27 @@ function applyConfig(base, config) {
     if (typeof config.prReportFile === "string") {
         base.prReportFile = path.resolve(base.cwd, config.prReportFile);
     }
+    if (typeof config.failOn === "string") {
+        base.failOn = ensureFailOn(config.failOn);
+    }
+    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");
@@ -257,10 +454,10 @@ function parseDependencyKinds(value) {
     return Array.from(new Set(mapped));
 }
 function ensureInitCiMode(value) {
-    if (value === "minimal" || value === "strict") {
+    if (value === "minimal" || value === "strict" || value === "enterprise") {
         return value;
     }
-    throw new Error("--mode must be minimal or strict");
+    throw new Error("--mode must be minimal, strict or enterprise");
 }
 function ensureInitCiSchedule(value) {
     if (value === "weekly" || value === "daily" || value === "off") {
@@ -268,3 +465,9 @@ function ensureInitCiSchedule(value) {
     }
     throw new Error("--schedule must be weekly, daily or off");
 }
+function ensureFailOn(value) {
+    if (value === "none" || value === "patch" || value === "minor" || value === "major" || value === "any") {
+        return value;
+    }
+    throw new Error("--fail-on must be none, patch, minor, major or any");
+}

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;
@@ -52,12 +52,12 @@ export async function warmCache(options) {
             }
         }
         else {
-            const fetched = await registryClient.resolveManyLatestVersions(needsFetch, {
+            const fetched = await registryClient.resolveManyPackageMetadata(needsFetch, {
                 concurrency: options.concurrency,
             });
-            for (const [pkg, version] of fetched.versions) {
-                if (version) {
-                    await cache.set(pkg, options.target, version, options.cacheTtlSeconds);
+            for (const [pkg, metadata] of fetched.metadata) {
+                if (metadata.latestVersion) {
+                    await cache.set(pkg, options.target, metadata.latestVersion, metadata.versions, options.cacheTtlSeconds);
                     warmed += 1;
                 }
             }

package/dist/index.d.ts

@@ -2,7 +2,8 @@ export { check } from "./core/check.js";
 export { upgrade } from "./core/upgrade.js";
 export { warmCache } from "./core/warm-cache.js";
 export { initCiWorkflow } from "./core/init-ci.js";
+export { saveBaseline, diffBaseline } from "./core/baseline.js";
 export { createSarifReport } from "./output/sarif.js";
 export { writeGitHubOutput, renderGitHubAnnotations } from "./output/github.js";
 export { renderPrReport } from "./output/pr-report.js";
-export type { CheckOptions, CheckResult, DependencyKind, OutputFormat, PackageUpdate, RunOptions, TargetLevel, UpgradeOptions, UpgradeResult, } from "./types/index.js";
+export type { CheckOptions, CheckResult, DependencyKind, FailOnLevel, OutputFormat, PackageUpdate, RunOptions, TargetLevel, UpgradeOptions, UpgradeResult, } from "./types/index.js";

package/dist/index.js

@@ -2,6 +2,7 @@ export { check } from "./core/check.js";
 export { upgrade } from "./core/upgrade.js";
 export { warmCache } from "./core/warm-cache.js";
 export { initCiWorkflow } from "./core/init-ci.js";
+export { saveBaseline, diffBaseline } from "./core/baseline.js";
 export { createSarifReport } from "./output/sarif.js";
 export { writeGitHubOutput, renderGitHubAnnotations } from "./output/github.js";
 export { renderPrReport } from "./output/pr-report.js";

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");