@rainy-updates/cli 0.5.1-rc.3 → 0.5.2-rc.1

package/dist/commands/unused/scanner.js

@@ -0,0 +1,129 @@
+import { promises as fs } from "node:fs";
+import path from "node:path";
+/**
+ * Extracts all imported package names from a single source file.
+ *
+ * Handles:
+ *   - ESM static:  import ... from "pkg"
+ *   - ESM dynamic: import("pkg")
+ *   - CJS:         require("pkg")
+ *
+ * Strips subpath imports (e.g. "lodash/merge" → "lodash"),
+ * skips relative imports and node: builtins.
+ */
+export function extractImportsFromSource(source) {
+    const names = new Set();
+    // ESM static import: from "pkg" or from 'pkg'
+    const staticImport = /from\s+['"]([^'"]+)['"]/g;
+    for (const match of source.matchAll(staticImport)) {
+        addPackageName(names, match[1]);
+    }
+    // ESM dynamic import: import("pkg") or import('pkg')
+    const dynamicImport = /\bimport\s*\(\s*['"]([^'"]+)['"]\s*\)/g;
+    for (const match of source.matchAll(dynamicImport)) {
+        addPackageName(names, match[1]);
+    }
+    // CJS require: require("pkg") or require('pkg')
+    const cjsRequire = /\brequire\s*\(\s*['"]([^'"]+)['"]\s*\)/g;
+    for (const match of source.matchAll(cjsRequire)) {
+        addPackageName(names, match[1]);
+    }
+    // export ... from "pkg"
+    const reExport = /\bexport\s+(?:\*|\{[^}]*\})\s+from\s+['"]([^'"]+)['"]/g;
+    for (const match of source.matchAll(reExport)) {
+        addPackageName(names, match[1]);
+    }
+    return names;
+}
+function addPackageName(names, specifier) {
+    // Skip relative imports, node: builtins, and bare file paths
+    if (specifier.startsWith(".") || specifier.startsWith("/"))
+        return;
+    if (specifier.startsWith("node:"))
+        return;
+    if (specifier.startsWith("bun:"))
+        return;
+    // Normalize package name (strip subpath): "lodash/merge" → "lodash"
+    // "@scope/pkg/subpath" → "@scope/pkg"
+    const name = extractPackageName(specifier);
+    if (name)
+        names.add(name);
+}
+export function extractPackageName(specifier) {
+    if (!specifier)
+        return null;
+    if (specifier.startsWith("@")) {
+        // Scoped: @scope/pkg or @scope/pkg/subpath
+        const parts = specifier.split("/");
+        if (parts.length < 2)
+            return null;
+        return `${parts[0]}/${parts[1]}`;
+    }
+    // Unscoped: pkg or pkg/subpath
+    return specifier.split("/")[0] ?? null;
+}
+const SOURCE_EXTENSIONS = new Set([
+    ".ts",
+    ".tsx",
+    ".js",
+    ".jsx",
+    ".mjs",
+    ".cjs",
+    ".mts",
+    ".cts",
+]);
+const IGNORED_DIRS = new Set([
+    "node_modules",
+    ".git",
+    "dist",
+    "build",
+    "out",
+    ".next",
+    ".nuxt",
+]);
+/**
+ * Recursively scans a directory and returns all imported package names
+ * found across all source files.
+ */
+export async function scanDirectory(dir) {
+    const allImports = new Set();
+    await walkDirectory(dir, allImports);
+    return allImports;
+}
+async function walkDirectory(dir, collector) {
+    let entries;
+    try {
+        entries = await fs.readdir(dir);
+    }
+    catch {
+        return;
+    }
+    const tasks = [];
+    for (const entryName of entries) {
+        if (IGNORED_DIRS.has(entryName))
+            continue;
+        const fullPath = path.join(dir, entryName);
+        tasks.push(fs
+            .stat(fullPath)
+            .then((stat) => {
+            if (stat.isDirectory()) {
+                return walkDirectory(fullPath, collector);
+            }
+            if (stat.isFile()) {
+                const ext = path.extname(entryName).toLowerCase();
+                if (!SOURCE_EXTENSIONS.has(ext))
+                    return;
+                return fs
+                    .readFile(fullPath, "utf8")
+                    .then((source) => {
+                    for (const name of extractImportsFromSource(source)) {
+                        collector.add(name);
+                    }
+                })
+                    .catch(() => undefined);
+            }
+        })
+            .catch(() => undefined));
+    }
+    await Promise.all(tasks);
+}

package/dist/config/loader.d.ts

@@ -1,4 +1,4 @@
-import type { CiProfile, DependencyKind, FailOnLevel, GroupBy, LogLevel, OutputFormat, TargetLevel } from "../types/index.js";
+import type { CiProfile, DependencyKind, FailOnLevel, GroupBy, LockfileMode, LogLevel, OutputFormat, TargetLevel } from "../types/index.js";
 export interface FileConfig {
     target?: TargetLevel;
     filter?: string;
@@ -12,7 +12,10 @@ export interface FileConfig {
     githubOutputFile?: string;
     sarifFile?: string;
     concurrency?: number;
+    registryTimeoutMs?: number;
+    registryRetries?: number;
     offline?: boolean;
+    stream?: boolean;
     policyFile?: string;
     prReportFile?: string;
     failOn?: FailOnLevel;
@@ -31,6 +34,7 @@ export interface FileConfig {
     prLimit?: number;
     onlyChanged?: boolean;
     ciProfile?: CiProfile;
+    lockfileMode?: LockfileMode;
     install?: boolean;
     packageManager?: "auto" | "npm" | "pnpm";
     sync?: boolean;

package/dist/config/policy.d.ts

@@ -11,6 +11,8 @@ export interface PolicyConfig {
         allowPrerelease?: boolean;
         group?: string;
         priority?: number;
+        target?: TargetLevel;
+        autofix?: boolean;
     }>;
 }
 export interface PolicyRule {
@@ -22,6 +24,8 @@ export interface PolicyRule {
     allowPrerelease?: boolean;
     group?: string;
     priority?: number;
+    target?: TargetLevel;
+    autofix?: boolean;
 }
 export interface ResolvedPolicy {
     ignorePatterns: string[];

package/dist/config/policy.js

@@ -46,6 +46,8 @@ function normalizeRule(rule) {
         allowPrerelease: rule.allowPrerelease === true,
         group: typeof rule.group === "string" && rule.group.trim().length > 0 ? rule.group.trim() : undefined,
         priority: asNonNegativeInt(rule.priority),
+        target: rule.target,
+        autofix: rule.autofix !== false,
     };
 }
 function asNonNegativeInt(value) {

package/dist/core/check.js

@@ -1,4 +1,5 @@
 import path from "node:path";
+import process from "node:process";
 import { collectDependencies, readManifest } from "../parsers/package-json.js";
 import { matchesPattern } from "../utils/pattern.js";
 import { applyRangeStyle, classifyDiff, clampTarget, pickTargetVersionFromAvailable } from "../utils/semver.js";
@@ -18,7 +19,10 @@ export async function check(options) {
     const packageDirs = await discoverPackageDirs(options.cwd, options.workspace);
     discoveryMs += Date.now() - discoveryStartedAt;
     const cache = await VersionCache.create();
-    const registryClient = new NpmRegistryClient(options.cwd);
+    const registryClient = new NpmRegistryClient(options.cwd, {
+        timeoutMs: options.registryTimeoutMs,
+        retries: options.registryRetries,
+    });
     const policy = await loadPolicy(options.cwd, options.policyFile);
     const updates = [];
     const errors = [];
@@ -30,6 +34,14 @@ export async function check(options) {
     const tasks = [];
     let skipped = 0;
     let cooldownSkipped = 0;
+    let streamedEvents = 0;
+    let policyOverridesApplied = 0;
+    const emitStream = (message) => {
+        if (!options.stream)
+            return;
+        streamedEvents += 1;
+        process.stdout.write(`${message}\n`);
+    };
     for (const packageDir of packageDirs) {
         let manifest;
         try {
@@ -49,10 +61,14 @@ export async function check(options) {
             const rule = resolvePolicyRule(dep.name, policy);
             if (rule?.ignore === true) {
                 skipped += 1;
+                policyOverridesApplied += 1;
+                emitStream(`[policy-ignore] ${dep.name}`);
                 continue;
             }
             if (policy.ignorePatterns.some((pattern) => matchesPattern(dep.name, pattern))) {
                 skipped += 1;
+                policyOverridesApplied += 1;
+                emitStream(`[policy-ignore-pattern] ${dep.name}`);
                 continue;
             }
             tasks.push({ packageDir, dependency: dep });
@@ -99,6 +115,8 @@ export async function check(options) {
             const registryStartedAt = Date.now();
             const fetched = await registryClient.resolveManyPackageMetadata(unresolvedPackages, {
                 concurrency: options.concurrency,
+                retries: options.registryRetries,
+                timeoutMs: options.registryTimeoutMs,
             });
             registryMs += Date.now() - registryStartedAt;
             const cacheWriteStartedAt = Date.now();
@@ -126,6 +144,7 @@ export async function check(options) {
                 }
                 else {
                     errors.push(`Unable to resolve ${packageName}: ${error}`);
+                    emitStream(`[error] Unable to resolve ${packageName}: ${error}`);
                 }
             }
             cacheMs += Date.now() - cacheStaleStartedAt;
@@ -136,12 +155,17 @@ export async function check(options) {
         if (!metadata?.latestVersion)
             continue;
         const rule = resolvePolicyRule(task.dependency.name, policy);
-        const effectiveTarget = clampTarget(options.target, rule?.maxTarget);
+        const baseTarget = rule?.target ?? options.target;
+        const effectiveTarget = clampTarget(baseTarget, rule?.maxTarget);
+        if (rule?.target || rule?.maxTarget || rule?.autofix === false) {
+            policyOverridesApplied += 1;
+        }
         const picked = pickTargetVersionFromAvailable(task.dependency.range, metadata.availableVersions, metadata.latestVersion, effectiveTarget);
         if (!picked)
             continue;
         if (shouldSkipByCooldown(picked, metadata.publishedAtByVersion, options.cooldownDays, policy.cooldownDays, rule?.cooldownDays)) {
             cooldownSkipped += 1;
+            emitStream(`[cooldown-skip] ${task.dependency.name}@${picked}`);
             continue;
         }
         const nextRange = applyRangeStyle(task.dependency.range, picked);
@@ -156,14 +180,17 @@ export async function check(options) {
             toVersionResolved: picked,
             diffType: classifyDiff(task.dependency.range, picked),
             filtered: false,
+            autofix: rule?.autofix !== false,
             reason: rule?.maxTarget ? `policy maxTarget=${rule.maxTarget}` : undefined,
         });
+        emitStream(`[update] ${task.dependency.name} ${task.dependency.range} -> ${nextRange} (${classifyDiff(task.dependency.range, picked)})`);
     }
     const grouped = groupUpdates(updates, options.groupBy);
     const groupedUpdates = grouped.length;
     const groupedSorted = sortUpdates(grouped.flatMap((group) => group.items));
     const groupedCapped = typeof options.groupMax === "number" ? groupedSorted.slice(0, options.groupMax) : groupedSorted;
-    const ruleLimited = applyRuleUpdateCaps(groupedCapped, policy);
+    const prioritized = applyPolicyPrioritySort(groupedCapped, policy);
+    const ruleLimited = applyRuleUpdateCaps(prioritized, policy);
     const prLimited = typeof options.prLimit === "number" ? ruleLimited.slice(0, options.prLimit) : ruleLimited;
     const limitedUpdates = sortUpdates(prLimited);
     const prLimitHit = typeof options.prLimit === "number" && groupedSorted.length > options.prLimit;
@@ -189,7 +216,9 @@ export async function check(options) {
         cooldownSkipped,
         ciProfile: options.ciProfile,
         prLimitHit,
+        policyOverridesApplied,
     }));
+    summary.streamedEvents = streamedEvents;
     return {
         projectPath: options.cwd,
         packagePaths: packageDirs,
@@ -266,6 +295,30 @@ function applyRuleUpdateCaps(updates, policy) {
     }
     return limited;
 }
+function applyPolicyPrioritySort(updates, policy) {
+    return [...updates].sort((left, right) => {
+        const leftPriority = resolvePolicyRule(left.name, policy)?.priority ?? 0;
+        const rightPriority = resolvePolicyRule(right.name, policy)?.priority ?? 0;
+        if (leftPriority !== rightPriority)
+            return rightPriority - leftPriority;
+        const byRisk = riskRank(left.diffType) - riskRank(right.diffType);
+        if (byRisk !== 0)
+            return byRisk;
+        const byName = left.name.localeCompare(right.name);
+        if (byName !== 0)
+            return byName;
+        return left.packagePath.localeCompare(right.packagePath);
+    });
+}
+function riskRank(value) {
+    if (value === "patch")
+        return 0;
+    if (value === "minor")
+        return 1;
+    if (value === "major")
+        return 2;
+    return 3;
+}
 function sortUpdates(updates) {
     return [...updates].sort((left, right) => {
         const byPath = left.packagePath.localeCompare(right.packagePath);

package/dist/core/fix-pr-batch.js

@@ -4,11 +4,12 @@ import os from "node:os";
 import path from "node:path";
 import { readManifest, writeManifest } from "../parsers/package-json.js";
 export async function applyFixPrBatches(options, result) {
-    if (!options.fixPr || result.updates.length === 0) {
+    const autofixUpdates = result.updates.filter((update) => update.autofix !== false);
+    if (!options.fixPr || autofixUpdates.length === 0) {
         return { applied: false, branches: [], commits: [] };
     }
     const baseRef = await resolveBaseRef(options.cwd, options.fixPrNoCheckout);
-    const groups = groupUpdates(result.updates, options.groupBy);
+    const groups = groupUpdates(autofixUpdates, options.groupBy);
     const plans = planFixPrBatches(groups, options.fixBranch ?? "chore/rainy-updates", options.fixPrBatchSize ?? 1);
     if (options.fixDryRun) {
         return { applied: false, branches: plans.map((plan) => plan.branchName), commits: [] };

package/dist/core/fix-pr.js

@@ -3,7 +3,8 @@ import path from "node:path";
 export async function applyFixPr(options, result, extraFiles) {
     if (!options.fixPr)
         return { applied: false };
-    if (result.updates.length === 0) {
+    const autofixUpdates = result.updates.filter((update) => update.autofix !== false);
+    if (autofixUpdates.length === 0) {
         return {
             applied: false,
             branchName: options.fixBranch ?? "chore/rainy-updates",
@@ -35,8 +36,11 @@ export async function applyFixPr(options, result, extraFiles) {
             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]
+    const manifestFiles = Array.from(new Set(autofixUpdates.map((update) => path.resolve(update.packagePath, "package.json"))));
+    const lockfileFiles = options.lockfileMode === "update"
+        ? (await collectChangedLockfiles(options.cwd)).map((entry) => path.resolve(options.cwd, entry))
+        : [];
+    const filesToStage = Array.from(new Set([...manifestFiles, ...extraFiles, ...lockfileFiles]
         .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) {
@@ -50,7 +54,7 @@ export async function applyFixPr(options, result, extraFiles) {
             commitSha: "",
         };
     }
-    const message = options.fixCommitMessage ?? `chore(deps): apply rainy-updates (${result.updates.length} updates)`;
+    const message = options.fixCommitMessage ?? `chore(deps): apply rainy-updates (${autofixUpdates.length} updates)`;
     await runGit(options.cwd, ["commit", "-m", message]);
     const rev = await runGit(options.cwd, ["rev-parse", "HEAD"]);
     return {
@@ -81,3 +85,14 @@ async function runGit(cwd, args, allowNonZero = false) {
         });
     });
 }
+async function collectChangedLockfiles(cwd) {
+    const status = await runGit(cwd, ["status", "--porcelain"], true);
+    const allowed = new Set(["package-lock.json", "npm-shrinkwrap.json", "pnpm-lock.yaml", "yarn.lock", "bun.lock"]);
+    const changed = status.stdout
+        .split(/\r?\n/)
+        .map((line) => line.trim())
+        .filter(Boolean)
+        .map((line) => line.slice(3).trim())
+        .filter((entry) => allowed.has(path.basename(entry)));
+    return Array.from(new Set(changed)).sort((a, b) => a.localeCompare(b));
+}

package/dist/core/impact.d.ts

@@ -0,0 +1,36 @@
+import type { ImpactScore, PackageUpdate } from "../types/index.js";
+/**
+ * Context fed into the impact scorer from the outer check/upgrade pipeline.
+ * All fields are optional — missing data degrades gracefully.
+ */
+export interface ImpactContext {
+    /** Names of packages that have a known CVE advisory (from `rup audit` cache). */
+    advisoryPackages?: ReadonlySet<string>;
+    /** How many workspace packages depend on this package (reverse-dep count). */
+    workspaceDependentCount?: (name: string) => number;
+}
+/**
+ * Compute an `ImpactScore` for a single pending package update.
+ *
+ * Algorithm:
+ *   score = diffWeight
+ *         + (advisoryBonus if CVE exists)
+ *         + min(workspaceCount × perPkg, cap)
+ *
+ * Clamped to [0, 100]. Rank thresholds:
+ *   ≥ 70 → critical
+ *   ≥ 45 → high
+ *   ≥ 20 → medium
+ *   <  20 → low
+ */
+export declare function computeImpactScore(update: PackageUpdate, context?: ImpactContext): ImpactScore;
+/**
+ * Batch-compute impact scores for all updates, returning a new array with
+ * `impactScore` populated on each entry. Non-mutating.
+ */
+export declare function applyImpactScores(updates: PackageUpdate[], context?: ImpactContext): PackageUpdate[];
+/**
+ * Returns the ANSI color badge string for terminal output.
+ * Used by the table renderer when --show-impact is active.
+ */
+export declare function impactBadge(score: ImpactScore): string;

package/dist/core/impact.js

@@ -0,0 +1,82 @@
+/** Weights for each semver diff type. */
+const DIFF_WEIGHT = {
+    patch: 10,
+    minor: 25,
+    major: 55,
+    latest: 30,
+};
+/** Advisory presence bonus — lifts total score significantly. */
+const ADVISORY_BONUS = 35;
+/** Points added per additional workspace package that uses this dep. */
+const WORKSPACE_SPREAD_PER_PKG = 5;
+/** Maximum workspace spread contribution (cap). */
+const WORKSPACE_SPREAD_CAP = 20;
+/**
+ * Compute an `ImpactScore` for a single pending package update.
+ *
+ * Algorithm:
+ *   score = diffWeight
+ *         + (advisoryBonus if CVE exists)
+ *         + min(workspaceCount × perPkg, cap)
+ *
+ * Clamped to [0, 100]. Rank thresholds:
+ *   ≥ 70 → critical
+ *   ≥ 45 → high
+ *   ≥ 20 → medium
+ *   <  20 → low
+ */
+export function computeImpactScore(update, context = {}) {
+    const diffTypeWeight = DIFF_WEIGHT[update.diffType] ?? DIFF_WEIGHT.latest;
+    const hasAdvisory = context.advisoryPackages?.has(update.name) ?? false;
+    const rawWorkspaceCount = context.workspaceDependentCount?.(update.name) ?? 0;
+    const affectedWorkspaceCount = Math.max(0, rawWorkspaceCount);
+    const advisoryPoints = hasAdvisory ? ADVISORY_BONUS : 0;
+    const workspacePoints = Math.min(affectedWorkspaceCount * WORKSPACE_SPREAD_PER_PKG, WORKSPACE_SPREAD_CAP);
+    const rawScore = diffTypeWeight + advisoryPoints + workspacePoints;
+    const score = Math.min(100, Math.max(0, rawScore));
+    const rank = scoreToRank(score);
+    return {
+        rank,
+        score,
+        factors: {
+            diffTypeWeight,
+            hasAdvisory,
+            affectedWorkspaceCount,
+        },
+    };
+}
+/**
+ * Batch-compute impact scores for all updates, returning a new array with
+ * `impactScore` populated on each entry. Non-mutating.
+ */
+export function applyImpactScores(updates, context = {}) {
+    return updates.map((u) => ({
+        ...u,
+        impactScore: computeImpactScore(u, context),
+    }));
+}
+function scoreToRank(score) {
+    if (score >= 70)
+        return "critical";
+    if (score >= 45)
+        return "high";
+    if (score >= 20)
+        return "medium";
+    return "low";
+}
+/**
+ * Returns the ANSI color badge string for terminal output.
+ * Used by the table renderer when --show-impact is active.
+ */
+export function impactBadge(score) {
+    switch (score.rank) {
+        case "critical":
+            return "\x1b[41m\x1b[97m CRITICAL \x1b[0m";
+        case "high":
+            return "\x1b[31m HIGH \x1b[0m";
+        case "medium":
+            return "\x1b[33m MED  \x1b[0m";
+        case "low":
+            return "\x1b[32m LOW  \x1b[0m";
+    }
+}

package/dist/core/init-ci.js

@@ -46,14 +46,14 @@ function installStep(packageManager) {
     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 ci \\\n            --workspace \\\n            --mode minimal \\\n            --ci \\\n            --format table\n`;
+    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 ci \\\n            --workspace \\\n            --mode minimal \\\n            --ci \\\n            --stream \\\n            --registry-timeout-ms 12000 \\\n            --registry-retries 4 \\\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 ci \\\n            --workspace \\\n            --mode strict \\\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`;
+    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 --registry-timeout-ms 12000 --registry-retries 4\n\n      - name: Run strict dependency check\n        run: |\n          npx @rainy-updates/cli ci \\\n            --workspace \\\n            --mode strict \\\n            --ci \\\n            --concurrency 32 \\\n            --stream \\\n            --registry-timeout-ms 12000 \\\n            --registry-retries 4 \\\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 ci \\\n            --workspace \\\n            --mode enterprise \\\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`;
+    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 --registry-timeout-ms 12000 --registry-retries 4\n\n      - name: Check updates with rollout controls\n        run: |\n          npx @rainy-updates/cli ci \\\n            --workspace \\\n            --mode enterprise \\\n            --concurrency 32 \\\n            --stream \\\n            --registry-timeout-ms 12000 \\\n            --registry-retries 4 \\\n            --lockfile-mode preserve \\\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 { BaselineOptions, CheckOptions, UpgradeOptions } from "../types/index.js";
+import type { BaselineOptions, CheckOptions, UpgradeOptions, AuditOptions, BisectOptions, HealthOptions, UnusedOptions, ResolveOptions, LicenseOptions, SnapshotOptions } from "../types/index.js";
 import type { InitCiMode, InitCiSchedule } from "./init-ci.js";
 export type ParsedCliArgs = {
     command: "check";
@@ -25,5 +25,26 @@ export type ParsedCliArgs = {
     options: BaselineOptions & {
         action: "save" | "check";
     };
+} | {
+    command: "bisect";
+    options: BisectOptions;
+} | {
+    command: "audit";
+    options: AuditOptions;
+} | {
+    command: "health";
+    options: HealthOptions;
+} | {
+    command: "unused";
+    options: UnusedOptions;
+} | {
+    command: "resolve";
+    options: ResolveOptions;
+} | {
+    command: "licenses";
+    options: LicenseOptions;
+} | {
+    command: "snapshot";
+    options: SnapshotOptions;
 };
 export declare function parseCliArgs(argv: string[]): Promise<ParsedCliArgs>;