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

package/dist/registry/npm.js

@@ -6,21 +6,23 @@ export class NpmRegistryClient {
     constructor() {
         this.requesterPromise = createRequester();
     }
-    async resolveLatestVersion(packageName, timeoutMs = DEFAULT_TIMEOUT_MS) {
+    async resolvePackageMetadata(packageName, timeoutMs = DEFAULT_TIMEOUT_MS) {
         const requester = await this.requesterPromise;
         let lastError = null;
         for (let attempt = 1; attempt <= 3; attempt += 1) {
             try {
                 const response = await requester(packageName, timeoutMs);
-                if (response.status === 404)
-                    return null;
+                if (response.status === 404) {
+                    return { latestVersion: null, versions: [] };
+                }
                 if (response.status === 429 || response.status >= 500) {
                     throw new Error(`Registry temporary error: ${response.status}`);
                 }
                 if (response.status < 200 || response.status >= 300) {
                     throw new Error(`Registry request failed: ${response.status}`);
                 }
-                return response.data?.["dist-tags"]?.latest ?? null;
+                const versions = Object.keys(response.data?.versions ?? {});
+                return { latestVersion: response.data?.["dist-tags"]?.latest ?? null, versions };
             }
             catch (error) {
                 lastError = String(error);
@@ -31,18 +33,22 @@ export class NpmRegistryClient {
         }
         throw new Error(`Unable to resolve ${packageName}: ${lastError ?? "unknown error"}`);
     }
-    async resolveManyLatestVersions(packageNames, options) {
+    async resolveLatestVersion(packageName, timeoutMs = DEFAULT_TIMEOUT_MS) {
+        const metadata = await this.resolvePackageMetadata(packageName, timeoutMs);
+        return metadata.latestVersion;
+    }
+    async resolveManyPackageMetadata(packageNames, options) {
         const unique = Array.from(new Set(packageNames));
-        const versions = new Map();
+        const metadata = new Map();
         const errors = new Map();
         const timeoutMs = options.timeoutMs ?? DEFAULT_TIMEOUT_MS;
         const results = await asyncPool(options.concurrency, unique.map((pkg) => async () => {
             try {
-                const latest = await this.resolveLatestVersion(pkg, timeoutMs);
-                return { pkg, latest, error: null };
+                const packageMetadata = await this.resolvePackageMetadata(pkg, timeoutMs);
+                return { pkg, packageMetadata, error: null };
             }
             catch (error) {
-                return { pkg, latest: null, error: String(error) };
+                return { pkg, packageMetadata: null, error: String(error) };
             }
         }));
         for (const result of results) {
@@ -52,11 +58,22 @@ export class NpmRegistryClient {
             if (result.error) {
                 errors.set(result.pkg, result.error);
             }
-            else {
-                versions.set(result.pkg, result.latest);
+            else if (result.packageMetadata) {
+                metadata.set(result.pkg, result.packageMetadata);
             }
         }
-        return { versions, errors };
+        return { metadata, errors };
+    }
+    async resolveManyLatestVersions(packageNames, options) {
+        const metadataResult = await this.resolveManyPackageMetadata(packageNames, options);
+        const versions = new Map();
+        for (const [name, value] of metadataResult.metadata) {
+            versions.set(name, value.latestVersion);
+        }
+        return {
+            versions,
+            errors: metadataResult.errors,
+        };
     }
 }
 function sleep(ms) {

package/dist/types/index.d.ts

@@ -1,6 +1,7 @@
 export type DependencyKind = "dependencies" | "devDependencies" | "optionalDependencies" | "peerDependencies";
 export type TargetLevel = "patch" | "minor" | "major" | "latest";
 export type OutputFormat = "table" | "json" | "minimal" | "github";
+export type FailOnLevel = "none" | "patch" | "minor" | "major" | "any";
 export interface RunOptions {
     cwd: string;
     target: TargetLevel;
@@ -18,6 +19,8 @@ export interface RunOptions {
     offline: boolean;
     policyFile?: string;
     prReportFile?: string;
+    failOn?: FailOnLevel;
+    maxUpdates?: number;
 }
 export interface CheckOptions extends RunOptions {
 }
@@ -26,6 +29,13 @@ export interface UpgradeOptions extends RunOptions {
     packageManager: "auto" | "npm" | "pnpm";
     sync: boolean;
 }
+export interface BaselineOptions {
+    cwd: string;
+    workspace: boolean;
+    includeKinds: DependencyKind[];
+    filePath: string;
+    ci: boolean;
+}
 export interface PackageDependency {
     name: string;
     range: string;
@@ -78,6 +88,7 @@ export interface CachedVersion {
     packageName: string;
     target: TargetLevel;
     latestVersion: string;
+    availableVersions: string[];
     fetchedAt: number;
     ttlSeconds: number;
 }

package/dist/utils/semver.d.ts

@@ -9,5 +9,6 @@ export declare function parseVersion(raw: string): ParsedVersion | null;
 export declare function compareVersions(a: ParsedVersion, b: ParsedVersion): number;
 export declare function classifyDiff(currentRange: string, nextVersion: string): TargetLevel;
 export declare function pickTargetVersion(currentRange: string, latestVersion: string, target: TargetLevel): string | null;
+export declare function pickTargetVersionFromAvailable(currentRange: string, availableVersions: string[], latestVersion: string, target: TargetLevel): string | null;
 export declare function applyRangeStyle(previousRange: string, version: string): string;
 export declare function clampTarget(requested: TargetLevel, maxAllowed?: TargetLevel): TargetLevel;

package/dist/utils/semver.js

@@ -64,6 +64,30 @@ export function pickTargetVersion(currentRange, latestVersion, target) {
     }
     return latestVersion;
 }
+export function pickTargetVersionFromAvailable(currentRange, availableVersions, latestVersion, target) {
+    const current = parseVersion(currentRange);
+    if (!current || target === "latest")
+        return latestVersion;
+    const parsed = availableVersions
+        .map((version) => ({ raw: version, parsed: parseVersion(version) }))
+        .filter((item) => item.parsed !== null)
+        .filter((item) => compareVersions(item.parsed, current) > 0)
+        .sort((a, b) => compareVersions(a.parsed, b.parsed));
+    if (parsed.length === 0)
+        return null;
+    if (target === "major") {
+        return parsed[parsed.length - 1]?.raw ?? null;
+    }
+    if (target === "minor") {
+        const sameMajor = parsed.filter((item) => item.parsed.major === current.major);
+        return sameMajor.length > 0 ? sameMajor[sameMajor.length - 1].raw : null;
+    }
+    if (target === "patch") {
+        const sameLine = parsed.filter((item) => item.parsed.major === current.major && item.parsed.minor === current.minor);
+        return sameLine.length > 0 ? sameLine[sameLine.length - 1].raw : null;
+    }
+    return latestVersion;
+}
 export function applyRangeStyle(previousRange, version) {
     const prefix = normalizeRangePrefix(previousRange);
     return `${prefix}${version}`;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@rainy-updates/cli",
-  "version": "0.4.0",
+  "version": "0.5.0-rc.1",
   "description": "Agentic CLI to check and upgrade npm/pnpm dependencies for CI workflows",
   "type": "module",
   "private": false,
@@ -36,7 +36,9 @@
     "dist",
     "README.md",
     "CHANGELOG.md",
-    "LICENSE"
+    "LICENSE",
+    "SECURITY.md",
+    "CODE_OF_CONDUCT.md"
   ],
   "scripts": {
     "clean": "rm -rf dist",
@@ -60,7 +62,6 @@
     "typescript": "^5.9.3"
   },
   "optionalDependencies": {
-    "better-sqlite3": "^12.6.2",
     "undici": "^7.22.0"
   }
 }