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

package/dist/core/fix-pr.js

@@ -0,0 +1,83 @@
+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,
+            branchName: options.fixBranch ?? "chore/rainy-updates",
+            commitSha: "",
+        };
+    }
+    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 headRef = await runGit(options.cwd, ["symbolic-ref", "--quiet", "--short", "HEAD"], true);
+    if (headRef.code !== 0 && !options.fixPrNoCheckout) {
+        throw new Error("Cannot run --fix-pr in detached HEAD state without --fix-pr-no-checkout.");
+    }
+    if (!options.fixPrNoCheckout) {
+        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,
+            commitSha: "",
+        };
+    }
+    const manifestFiles = Array.from(new Set(result.updates.map((update) => path.resolve(update.packagePath, "package.json"))));
+    const filesToStage = Array.from(new Set([...manifestFiles, ...extraFiles]
+        .map((entry) => path.resolve(options.cwd, entry))
+        .filter((entry) => entry.startsWith(path.resolve(options.cwd) + path.sep) || entry === path.resolve(options.cwd)))).sort((a, b) => a.localeCompare(b));
+    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,
+            commitSha: "",
+        };
+    }
+    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,24 @@ export async function parseCliArgs(argv) {
         prReportFile: undefined,
         failOn: "none",
         maxUpdates: undefined,
+        fixPr: false,
+        fixBranch: "chore/rainy-updates",
+        fixCommitMessage: undefined,
+        fixDryRun: false,
+        fixPrNoCheckout: false,
+        noPrReport: false,
+        logLevel: "info",
     };
     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 +123,7 @@ export async function parseCliArgs(argv) {
             continue;
         }
         if (current === "--json-file" && next) {
-            base.jsonFile = path.resolve(next);
+            jsonFileRaw = next;
             index += 1;
             continue;
         }
@@ -119,7 +131,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 +139,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 +163,7 @@ export async function parseCliArgs(argv) {
             continue;
         }
         if (current === "--policy-file" && next) {
-            base.policyFile = path.resolve(next);
+            policyFileRaw = next;
             index += 1;
             continue;
         }
@@ -159,7 +171,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 +182,46 @@ 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 === "--fix-pr-no-checkout") {
+            base.fixPrNoCheckout = true;
+            continue;
+        }
+        if (current === "--log-level" && next) {
+            base.logLevel = ensureLogLevel(next);
+            index += 1;
+            continue;
+        }
+        if (current === "--log-level") {
+            throw new Error("Missing value for --log-level");
+        }
         if (current === "--install" && command === "upgrade") {
             continue;
         }
@@ -249,6 +301,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 +408,27 @@ 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.fixPrNoCheckout === "boolean") {
+        base.fixPrNoCheckout = config.fixPrNoCheckout;
+    }
+    if (typeof config.noPrReport === "boolean") {
+        base.noPrReport = config.noPrReport;
+    }
+    if (typeof config.logLevel === "string") {
+        base.logLevel = ensureLogLevel(config.logLevel);
+    }
 }
 function parsePackageManager(args) {
     const index = args.indexOf("--pm");
@@ -353,10 +447,16 @@ function ensureTarget(value) {
     throw new Error("--target must be patch, minor, major, latest");
 }
 function ensureFormat(value) {
-    if (value === "table" || value === "json" || value === "minimal" || value === "github") {
+    if (value === "table" || value === "json" || value === "minimal" || value === "github" || value === "metrics") {
+        return value;
+    }
+    throw new Error("--format must be table, json, minimal, github or metrics");
+}
+function ensureLogLevel(value) {
+    if (value === "error" || value === "warn" || value === "info" || value === "debug") {
         return value;
     }
-    throw new Error("--format must be table, json, minimal or github");
+    throw new Error("--log-level must be error, warn, info or debug");
 }
 function parseDependencyKinds(value) {
     const mapped = value

package/dist/core/summary.d.ts

@@ -0,0 +1,22 @@
+import type { FailOnLevel, FailReason, PackageUpdate, Summary } from "../types/index.js";
+export interface DurationInput {
+    totalMs: number;
+    discoveryMs: number;
+    registryMs: number;
+    cacheMs: number;
+}
+export declare function createSummary(input: {
+    scannedPackages: number;
+    totalDependencies: number;
+    checkedDependencies: number;
+    updatesFound: number;
+    upgraded: number;
+    skipped: number;
+    warmedPackages: number;
+    errors: string[];
+    warnings: string[];
+    durations: DurationInput;
+}): Summary;
+export declare function finalizeSummary(summary: Summary): Summary;
+export declare function resolveFailReason(updates: PackageUpdate[], errors: string[], failOn: FailOnLevel | undefined, maxUpdates: number | undefined, ciMode: boolean): FailReason;
+export declare function shouldFailForUpdates(updates: PackageUpdate[], failOn: FailOnLevel): boolean;

package/dist/core/summary.js

@@ -0,0 +1,78 @@
+export function createSummary(input) {
+    const offlineCacheMiss = input.errors.filter((error) => isOfflineCacheMissError(error)).length;
+    const registryFailure = input.errors.filter((error) => isRegistryFailureError(error)).length;
+    const staleCache = input.warnings.filter((warning) => warning.includes("Using stale cache")).length;
+    return {
+        contractVersion: "2",
+        scannedPackages: input.scannedPackages,
+        totalDependencies: input.totalDependencies,
+        checkedDependencies: input.checkedDependencies,
+        updatesFound: input.updatesFound,
+        upgraded: input.upgraded,
+        skipped: input.skipped,
+        warmedPackages: input.warmedPackages,
+        failReason: "none",
+        errorCounts: {
+            total: input.errors.length,
+            offlineCacheMiss,
+            registryFailure,
+            other: 0,
+        },
+        warningCounts: {
+            total: input.warnings.length,
+            staleCache,
+            other: 0,
+        },
+        durationMs: {
+            total: Math.max(0, Math.round(input.durations.totalMs)),
+            discovery: Math.max(0, Math.round(input.durations.discoveryMs)),
+            registry: Math.max(0, Math.round(input.durations.registryMs)),
+            cache: Math.max(0, Math.round(input.durations.cacheMs)),
+            render: 0,
+        },
+        fixPrApplied: false,
+        fixBranchName: "",
+        fixCommitSha: "",
+    };
+}
+export function finalizeSummary(summary) {
+    const errorOther = summary.errorCounts.total - summary.errorCounts.offlineCacheMiss - summary.errorCounts.registryFailure;
+    const warningOther = summary.warningCounts.total - summary.warningCounts.staleCache;
+    summary.errorCounts.other = Math.max(0, errorOther);
+    summary.warningCounts.other = Math.max(0, warningOther);
+    return summary;
+}
+export function resolveFailReason(updates, errors, failOn, maxUpdates, ciMode) {
+    if (errors.some((error) => isOfflineCacheMissError(error))) {
+        return "offline-cache-miss";
+    }
+    if (errors.some((error) => isRegistryFailureError(error))) {
+        return "registry-failure";
+    }
+    if (typeof maxUpdates === "number" && updates.length > maxUpdates) {
+        return "updates-threshold";
+    }
+    const effectiveFailOn = failOn && failOn !== "none" ? failOn : ciMode ? "any" : "none";
+    if (shouldFailForUpdates(updates, effectiveFailOn)) {
+        return "severity-threshold";
+    }
+    return "none";
+}
+export function shouldFailForUpdates(updates, failOn) {
+    if (failOn === "none")
+        return false;
+    if (failOn === "any" || failOn === "patch")
+        return updates.length > 0;
+    if (failOn === "minor")
+        return updates.some((update) => update.diffType === "minor" || update.diffType === "major");
+    return updates.some((update) => update.diffType === "major");
+}
+function isOfflineCacheMissError(value) {
+    return value.includes("Offline cache miss");
+}
+function isRegistryFailureError(value) {
+    return (value.includes("Unable to resolve") ||
+        value.includes("Unable to warm") ||
+        value.includes("Registry request failed") ||
+        value.includes("Registry temporary error"));
+}

package/dist/core/warm-cache.js

@@ -4,13 +4,23 @@ import { VersionCache } from "../cache/cache.js";
 import { NpmRegistryClient } from "../registry/npm.js";
 import { detectPackageManager } from "../pm/detect.js";
 import { discoverPackageDirs } from "../workspace/discover.js";
+import { createSummary, finalizeSummary } from "./summary.js";
 export async function warmCache(options) {
+    const startedAt = Date.now();
+    let discoveryMs = 0;
+    let cacheMs = 0;
+    let registryMs = 0;
+    const discoveryStartedAt = Date.now();
     const packageManager = await detectPackageManager(options.cwd);
     const packageDirs = await discoverPackageDirs(options.cwd, options.workspace);
+    discoveryMs += Date.now() - discoveryStartedAt;
     const cache = await VersionCache.create();
-    const registryClient = new NpmRegistryClient();
+    const registryClient = new NpmRegistryClient(options.cwd);
     const errors = [];
     const warnings = [];
+    if (cache.degraded) {
+        warnings.push("SQLite cache backend unavailable in Bun runtime. Falling back to file cache backend.");
+    }
     let totalDependencies = 0;
     const packageNames = new Set();
     for (const packageDir of packageDirs) {
@@ -30,16 +40,19 @@ export async function warmCache(options) {
             errors.push(`Failed to read package.json in ${packageDir}: ${String(error)}`);
         }
     }
-    const names = Array.from(packageNames);
+    const names = Array.from(packageNames).sort((a, b) => a.localeCompare(b));
     const needsFetch = [];
+    const cacheLookupStartedAt = Date.now();
     for (const pkg of names) {
         const valid = await cache.getValid(pkg, options.target);
         if (!valid)
             needsFetch.push(pkg);
     }
+    cacheMs += Date.now() - cacheLookupStartedAt;
     let warmed = 0;
     if (needsFetch.length > 0) {
         if (options.offline) {
+            const cacheFallbackStartedAt = Date.now();
             for (const pkg of needsFetch) {
                 const stale = await cache.getAny(pkg, options.target);
                 if (stale) {
@@ -50,23 +63,30 @@ export async function warmCache(options) {
                     errors.push(`Offline cache miss for ${pkg}. Cannot warm cache in --offline mode.`);
                 }
             }
+            cacheMs += Date.now() - cacheFallbackStartedAt;
         }
         else {
+            const registryStartedAt = Date.now();
             const fetched = await registryClient.resolveManyPackageMetadata(needsFetch, {
                 concurrency: options.concurrency,
             });
+            registryMs += Date.now() - registryStartedAt;
+            const cacheWriteStartedAt = Date.now();
             for (const [pkg, metadata] of fetched.metadata) {
                 if (metadata.latestVersion) {
                     await cache.set(pkg, options.target, metadata.latestVersion, metadata.versions, options.cacheTtlSeconds);
                     warmed += 1;
                 }
             }
+            cacheMs += Date.now() - cacheWriteStartedAt;
             for (const [pkg, error] of fetched.errors) {
                 errors.push(`Unable to warm ${pkg}: ${error}`);
             }
         }
     }
-    const summary = {
+    const sortedErrors = [...errors].sort((a, b) => a.localeCompare(b));
+    const sortedWarnings = [...warnings].sort((a, b) => a.localeCompare(b));
+    const summary = finalizeSummary(createSummary({
         scannedPackages: packageDirs.length,
         totalDependencies,
         checkedDependencies: names.length,
@@ -74,7 +94,15 @@ export async function warmCache(options) {
         upgraded: 0,
         skipped: 0,
         warmedPackages: warmed,
-    };
+        errors: sortedErrors,
+        warnings: sortedWarnings,
+        durations: {
+            totalMs: Date.now() - startedAt,
+            discoveryMs,
+            registryMs,
+            cacheMs,
+        },
+    }));
     return {
         projectPath: options.cwd,
         packagePaths: packageDirs,
@@ -83,7 +111,7 @@ export async function warmCache(options) {
         timestamp: new Date().toISOString(),
         summary,
         updates: [],
-        errors,
-        warnings,
+        errors: sortedErrors,
+        warnings: sortedWarnings,
     };
 }

package/dist/output/format.js

@@ -1,7 +1,8 @@
 import { renderGitHubAnnotations } from "./github.js";
+import { stableStringify } from "../utils/stable-json.js";
 export function renderResult(result, format) {
     if (format === "json") {
-        return JSON.stringify(result, null, 2);
+        return stableStringify(result, 2);
     }
     if (format === "minimal") {
         if (result.updates.length === 0 && result.summary.warmedPackages > 0) {
@@ -16,6 +17,23 @@ export function renderResult(result, format) {
     if (format === "github") {
         return renderGitHubAnnotations(result);
     }
+    if (format === "metrics") {
+        return [
+            `contract_version=${result.summary.contractVersion}`,
+            `updates_found=${result.summary.updatesFound}`,
+            `errors_count=${result.summary.errorCounts.total}`,
+            `warnings_count=${result.summary.warningCounts.total}`,
+            `checked_dependencies=${result.summary.checkedDependencies}`,
+            `scanned_packages=${result.summary.scannedPackages}`,
+            `warmed_packages=${result.summary.warmedPackages}`,
+            `fail_reason=${result.summary.failReason}`,
+            `duration_total_ms=${result.summary.durationMs.total}`,
+            `duration_discovery_ms=${result.summary.durationMs.discovery}`,
+            `duration_registry_ms=${result.summary.durationMs.registry}`,
+            `duration_cache_ms=${result.summary.durationMs.cache}`,
+            `duration_render_ms=${result.summary.durationMs.render}`,
+        ].join("\n");
+    }
     const lines = [];
     lines.push(`Project: ${result.projectPath}`);
     lines.push(`Scanned packages: ${result.summary.scannedPackages}`);
@@ -52,5 +70,9 @@ 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`);
+    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"})`);
+    }
     return lines.join("\n");
 }

package/dist/output/github.js

@@ -1,26 +1,40 @@
-import { promises as fs } from "node:fs";
-import path from "node:path";
+import { writeFileAtomic } from "../utils/io.js";
 export async function writeGitHubOutput(filePath, result) {
     const lines = [
+        `contract_version=${result.summary.contractVersion}`,
         `updates_found=${result.summary.updatesFound}`,
-        `errors_count=${result.errors.length}`,
-        `warnings_count=${result.warnings.length}`,
+        `errors_count=${result.summary.errorCounts.total}`,
+        `warnings_count=${result.summary.warningCounts.total}`,
         `checked_dependencies=${result.summary.checkedDependencies}`,
         `scanned_packages=${result.summary.scannedPackages}`,
         `warmed_packages=${result.summary.warmedPackages}`,
+        `fail_reason=${result.summary.failReason}`,
+        `duration_total_ms=${result.summary.durationMs.total}`,
+        `duration_discovery_ms=${result.summary.durationMs.discovery}`,
+        `duration_registry_ms=${result.summary.durationMs.registry}`,
+        `duration_cache_ms=${result.summary.durationMs.cache}`,
+        `duration_render_ms=${result.summary.durationMs.render}`,
+        `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");
+    await writeFileAtomic(filePath, lines.join("\n") + "\n");
 }
 export function renderGitHubAnnotations(result) {
     const lines = [];
-    for (const update of result.updates) {
+    const sortedUpdates = [...result.updates].sort((left, right) => {
+        const byName = left.name.localeCompare(right.name);
+        if (byName !== 0)
+            return byName;
+        return left.packagePath.localeCompare(right.packagePath);
+    });
+    for (const update of sortedUpdates) {
         lines.push(`::notice title=Dependency Update::${update.name} ${update.fromRange} -> ${update.toRange} (${update.packagePath})`);
     }
-    for (const warning of result.warnings) {
+    for (const warning of [...result.warnings].sort((a, b) => a.localeCompare(b))) {
         lines.push(`::warning title=Rainy Updates::${warning}`);
     }
-    for (const error of result.errors) {
+    for (const error of [...result.errors].sort((a, b) => a.localeCompare(b))) {
         lines.push(`::error title=Rainy Updates::${error}`);
     }
     if (lines.length === 0) {

package/dist/output/sarif.js

@@ -4,7 +4,13 @@ import { fileURLToPath } from "node:url";
 export function createSarifReport(result) {
     const dependencyRuleId = "rainy-updates/dependency-update";
     const runtimeRuleId = "rainy-updates/runtime-error";
-    const updateResults = result.updates.map((update) => ({
+    const sortedUpdates = [...result.updates].sort((left, right) => {
+        const byName = left.name.localeCompare(right.name);
+        if (byName !== 0)
+            return byName;
+        return left.packagePath.localeCompare(right.packagePath);
+    });
+    const updateResults = sortedUpdates.map((update) => ({
         ruleId: dependencyRuleId,
         level: "warning",
         message: {
@@ -26,7 +32,7 @@ export function createSarifReport(result) {
             resolvedVersion: update.toVersionResolved,
         },
     }));
-    const errorResults = result.errors.map((error) => ({
+    const errorResults = [...result.errors].sort((a, b) => a.localeCompare(b)).map((error) => ({
         ruleId: runtimeRuleId,
         level: "error",
         message: {
@@ -57,6 +63,14 @@ export function createSarifReport(result) {
                     },
                 },
                 results: [...updateResults, ...errorResults],
+                properties: {
+                    contractVersion: result.summary.contractVersion,
+                    failReason: result.summary.failReason,
+                    updatesFound: result.summary.updatesFound,
+                    errorsCount: result.summary.errorCounts.total,
+                    warningsCount: result.summary.warningCounts.total,
+                    durationMs: result.summary.durationMs,
+                },
             },
         ],
     };

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[];