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

package/dist/core/baseline.d.ts

@@ -0,0 +1,23 @@
+import type { BaselineOptions, DependencyKind } from "../types/index.js";
+interface BaselineEntry {
+    packagePath: string;
+    kind: DependencyKind;
+    name: string;
+    range: string;
+}
+export interface BaselineSaveResult {
+    filePath: string;
+    entries: number;
+}
+export interface BaselineDiffResult {
+    filePath: string;
+    added: BaselineEntry[];
+    removed: BaselineEntry[];
+    changed: Array<{
+        before: BaselineEntry;
+        after: BaselineEntry;
+    }>;
+}
+export declare function saveBaseline(options: BaselineOptions): Promise<BaselineSaveResult>;
+export declare function diffBaseline(options: BaselineOptions): Promise<BaselineDiffResult>;
+export {};

package/dist/core/baseline.js

@@ -0,0 +1,72 @@
+import { promises as fs } from "node:fs";
+import path from "node:path";
+import { collectDependencies, readManifest } from "../parsers/package-json.js";
+import { discoverPackageDirs } from "../workspace/discover.js";
+export async function saveBaseline(options) {
+    const entries = await collectBaselineEntries(options.cwd, options.workspace, options.includeKinds);
+    const payload = {
+        version: 1,
+        createdAt: new Date().toISOString(),
+        entries,
+    };
+    await fs.mkdir(path.dirname(options.filePath), { recursive: true });
+    await fs.writeFile(options.filePath, JSON.stringify(payload, null, 2) + "\n", "utf8");
+    return {
+        filePath: options.filePath,
+        entries: entries.length,
+    };
+}
+export async function diffBaseline(options) {
+    const content = await fs.readFile(options.filePath, "utf8");
+    const baseline = JSON.parse(content);
+    const currentEntries = await collectBaselineEntries(options.cwd, options.workspace, options.includeKinds);
+    const baselineMap = new Map(baseline.entries.map((entry) => [toKey(entry), entry]));
+    const currentMap = new Map(currentEntries.map((entry) => [toKey(entry), entry]));
+    const added = [];
+    const removed = [];
+    const changed = [];
+    for (const [key, current] of currentMap) {
+        const base = baselineMap.get(key);
+        if (!base) {
+            added.push(current);
+            continue;
+        }
+        if (base.range !== current.range) {
+            changed.push({ before: base, after: current });
+        }
+    }
+    for (const [key, base] of baselineMap) {
+        if (!currentMap.has(key)) {
+            removed.push(base);
+        }
+    }
+    return {
+        filePath: options.filePath,
+        added: sortEntries(added),
+        removed: sortEntries(removed),
+        changed: changed.sort((a, b) => toKey(a.after).localeCompare(toKey(b.after))),
+    };
+}
+async function collectBaselineEntries(cwd, workspace, includeKinds) {
+    const packageDirs = await discoverPackageDirs(cwd, workspace);
+    const entries = [];
+    for (const packageDir of packageDirs) {
+        const manifest = await readManifest(packageDir);
+        const deps = collectDependencies(manifest, includeKinds);
+        for (const dep of deps) {
+            entries.push({
+                packagePath: path.relative(cwd, packageDir) || ".",
+                kind: dep.kind,
+                name: dep.name,
+                range: dep.range,
+            });
+        }
+    }
+    return sortEntries(entries);
+}
+function toKey(entry) {
+    return `${entry.packagePath}::${entry.kind}::${entry.name}`;
+}
+function sortEntries(entries) {
+    return [...entries].sort((a, b) => toKey(a).localeCompare(toKey(b)));
+}

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

@@ -1,4 +1,10 @@
-export declare function initCiWorkflow(cwd: string, force: boolean): Promise<{
+export type InitCiMode = "minimal" | "strict" | "enterprise";
+export type InitCiSchedule = "weekly" | "daily" | "off";
+export interface InitCiOptions {
+    mode: InitCiMode;
+    schedule: InitCiSchedule;
+}
+export declare function initCiWorkflow(cwd: string, force: boolean, options: InitCiOptions): Promise<{
     path: string;
     created: boolean;
 }>;

package/dist/core/init-ci.js

@@ -1,20 +1,59 @@
-import { promises as fs } from "node:fs";
+import { access, writeFile, mkdir } from "node:fs/promises";
 import path from "node:path";
-export async function initCiWorkflow(cwd, force) {
+export async function initCiWorkflow(cwd, force, options) {
     const workflowPath = path.join(cwd, ".github", "workflows", "rainy-updates.yml");
     try {
         if (!force) {
-            await fs.access(workflowPath);
+            await access(workflowPath);
             return { path: workflowPath, created: false };
         }
     }
     catch {
         // missing file, continue create
     }
-    await fs.mkdir(path.dirname(workflowPath), { recursive: true });
-    await fs.writeFile(workflowPath, workflowTemplate(), "utf8");
+    const packageManager = await detectPackageManager(cwd);
+    const scheduleBlock = renderScheduleBlock(options.schedule);
+    const workflow = options.mode === "minimal"
+        ? minimalWorkflowTemplate(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 };
 }
-function workflowTemplate() {
-    return `name: Rainy Updates\n\non:\n  schedule:\n    - cron: '0 8 * * 1'\n  workflow_dispatch:\n\njobs:\n  dependency-updates:\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      - name: Run rainy updates\n        run: |\n          npx @rainy-updates/cli check \\\n            --workspace \\\n            --ci \\\n            --concurrency 32 \\\n            --format github \\\n            --json-file .artifacts/deps-report.json \\\n            --sarif-file .artifacts/deps-report.sarif \\\n            --github-output $GITHUB_OUTPUT\n\n      - name: Upload SARIF\n        uses: github/codeql-action/upload-sarif@v3\n        with:\n          sarif_file: .artifacts/deps-report.sarif\n`;
+async function detectPackageManager(cwd) {
+    const pnpmLock = path.join(cwd, "pnpm-lock.yaml");
+    try {
+        await access(pnpmLock);
+        return "pnpm";
+    }
+    catch {
+        return "npm";
+    }
+}
+function renderScheduleBlock(schedule) {
+    if (schedule === "off") {
+        return "  workflow_dispatch:";
+    }
+    const cron = schedule === "daily" ? "0 8 * * *" : "0 8 * * 1";
+    return `  schedule:\n    - cron: '${cron}'\n  workflow_dispatch:`;
+}
+function installStep(packageManager) {
+    if (packageManager === "pnpm") {
+        return `      - name: Setup pnpm\n        uses: pnpm/action-setup@v4\n        with:\n          version: 9\n\n      - name: Install dependencies\n        run: pnpm install --frozen-lockfile`;
+    }
+    return `      - name: Install dependencies\n        run: npm ci`;
+}
+function minimalWorkflowTemplate(scheduleBlock, packageManager) {
+    return `name: Rainy Updates\n\non:\n${scheduleBlock}\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: Run dependency check\n        run: |\n          npx @rainy-updates/cli check \\\n            --workspace \\\n            --ci \\\n            --format table\n`;
+}
+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,5 @@
-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";
     options: CheckOptions;
@@ -10,8 +11,16 @@ export type ParsedCliArgs = {
     options: CheckOptions;
 } | {
     command: "init-ci";
-    options: CheckOptions & {
+    options: {
+        cwd: string;
         force: boolean;
+        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,8 +34,14 @@ export async function parseCliArgs(argv) {
         offline: false,
         policyFile: undefined,
         prReportFile: undefined,
+        failOn: "none",
+        maxUpdates: undefined,
     };
     let force = false;
+    let initCiMode = "enterprise";
+    let initCiSchedule = "weekly";
+    let baselineAction = "check";
+    let baselineFilePath = path.resolve(base.cwd, ".rainy-updates-baseline.json");
     let resolvedConfig = await loadConfig(base.cwd);
     applyConfig(base, resolvedConfig);
     for (let index = 0; index < args.length; index += 1) {
@@ -46,23 +52,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) {
@@ -72,11 +91,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;
@@ -90,16 +115,25 @@ export async function parseCliArgs(argv) {
             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);
             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);
             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) {
@@ -109,6 +143,9 @@ 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;
@@ -118,20 +155,99 @@ export async function parseCliArgs(argv) {
             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);
             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 === "--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 (command === "upgrade") {
         const configPm = resolvedConfig.packageManager;
@@ -148,7 +264,28 @@ export async function parseCliArgs(argv) {
         return { command, options: base };
     }
     if (command === "init-ci") {
-        return { command, options: { ...base, force } };
+        return {
+            command,
+            options: {
+                cwd: base.cwd,
+                force,
+                mode: initCiMode,
+                schedule: initCiSchedule,
+            },
+        };
+    }
+    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",
@@ -192,6 +329,12 @@ 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;
+    }
 }
 function parsePackageManager(args) {
     const index = args.indexOf("--pm");
@@ -236,3 +379,21 @@ function parseDependencyKinds(value) {
     }
     return Array.from(new Set(mapped));
 }
+function ensureInitCiMode(value) {
+    if (value === "minimal" || value === "strict" || value === "enterprise") {
+        return value;
+    }
+    throw new Error("--mode must be minimal, strict or enterprise");
+}
+function ensureInitCiSchedule(value) {
+    if (value === "weekly" || value === "daily" || value === "off") {
+        return 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

@@ -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/sarif.js

@@ -1,3 +1,6 @@
+import { readFileSync } from "node:fs";
+import path from "node:path";
+import { fileURLToPath } from "node:url";
 export function createSarifReport(result) {
     const dependencyRuleId = "rainy-updates/dependency-update";
     const runtimeRuleId = "rainy-updates/runtime-error";
@@ -38,7 +41,7 @@ export function createSarifReport(result) {
                 tool: {
                     driver: {
                         name: "@rainy-updates/cli",
-                        version: "0.1.0",
+                        version: getToolVersion(),
                         rules: [
                             {
                                 id: dependencyRuleId,
@@ -58,3 +61,20 @@ export function createSarifReport(result) {
         ],
     };
 }
+let TOOL_VERSION_CACHE = null;
+function getToolVersion() {
+    if (TOOL_VERSION_CACHE)
+        return TOOL_VERSION_CACHE;
+    try {
+        const currentFile = fileURLToPath(import.meta.url);
+        const packageJsonPath = path.resolve(path.dirname(currentFile), "../../package.json");
+        const content = readFileSync(packageJsonPath, "utf8");
+        const parsed = JSON.parse(content);
+        TOOL_VERSION_CACHE = parsed.version ?? "0.0.0";
+        return TOOL_VERSION_CACHE;
+    }
+    catch {
+        TOOL_VERSION_CACHE = "0.0.0";
+        return TOOL_VERSION_CACHE;
+    }
+}

package/dist/registry/npm.d.ts

@@ -3,12 +3,23 @@ export interface ResolveManyOptions {
     timeoutMs?: number;
 }
 export interface ResolveManyResult {
-    versions: Map<string, string | null>;
+    metadata: Map<string, {
+        latestVersion: string | null;
+        versions: string[];
+    }>;
     errors: Map<string, string>;
 }
 export declare class NpmRegistryClient {
     private readonly requesterPromise;
     constructor();
+    resolvePackageMetadata(packageName: string, timeoutMs?: number): Promise<{
+        latestVersion: string | null;
+        versions: string[];
+    }>;
     resolveLatestVersion(packageName: string, timeoutMs?: number): Promise<string | null>;
-    resolveManyLatestVersions(packageNames: string[], options: ResolveManyOptions): Promise<ResolveManyResult>;
+    resolveManyPackageMetadata(packageNames: string[], options: ResolveManyOptions): Promise<ResolveManyResult>;
+    resolveManyLatestVersions(packageNames: string[], options: ResolveManyOptions): Promise<{
+        versions: Map<string, string | null>;
+        errors: Map<string, string>;
+    }>;
 }