@rainy-updates/cli 0.5.2-rc.2 → 0.5.3

package/CHANGELOG.md

@@ -2,6 +2,113 @@
 
 All notable changes to this project are documented in this file.
 
+## [0.5.3] - 2026-03-01
+
+GA stabilization and review-centered workflow refinement.
+
+### Added
+
+- **Dedicated risk engine layer** under `src/risk/`:
+  - formal risk scoring with `riskScore`, `riskLevel`, `riskReasons`, `riskCategories`, and `recommendedAction`,
+  - deterministic scoring for:
+    - known vulnerabilities,
+    - install lifecycle scripts,
+    - typosquatting heuristic,
+    - newly published packages,
+    - suspicious metadata,
+    - mutable git/http dependencies,
+    - maintainer stability heuristic,
+    - peer conflicts,
+    - license violations,
+    - stale/deprecated health signals,
+    - major version jumps.
+- **Benchmark tooling and methodology**:
+  - `scripts/generate-benchmark-fixtures.mjs`,
+  - `scripts/benchmark.mjs`,
+  - generated fixtures under `benchmarks/fixtures/`,
+  - benchmark methodology doc: `docs/benchmarks.md`.
+- **New workflow docs**:
+  - `docs/command-model.md`
+  - `docs/review-workflow.md`
+  - `docs/risk-engine.md`
+
+### Changed
+
+- `review` is now the explicit product center:
+  - `check` detects,
+  - `doctor` summarizes,
+  - `review` decides,
+  - `upgrade` applies.
+- CLI help, README, and docs now reflect the review-centered workflow instead of a flat command surface.
+- Review outputs now carry formal risk engine results instead of ad hoc composite signals.
+- TUI language has been upgraded to decision-oriented semantics:
+  - review queue,
+  - decision panel,
+  - explicit state labels,
+  - recommended action per candidate.
+- GitHub annotations, SARIF, and human-readable output now expose formal risk score/action metadata additively.
+
+### Benchmarks
+
+- Added package scripts for reproducible benchmark runs:
+  - `bench:fixtures`
+  - `bench:check`
+  - `bench:review`
+  - `bench:resolve`
+  - `bench:ci`
+
+## [0.5.2] - 2026-03-01
+
+### Added
+
+- **New `review` command**: Aggregates pending updates with security, peer-conflict, license, health, and unused-dependency signals for guided dependency review.
+  - `--interactive` launches the upgraded Ink review TUI.
+  - `--security-only`, `--risk <level>`, and `--diff <level>` filter the review set.
+  - `--apply-selected` can apply the filtered/selected updates after review.
+- **New `doctor` command**: Produces a fast dependency verdict for local triage and CI summaries.
+  - Verdict classes: `safe`, `review`, `blocked`, `actionable`.
+  - `--verdict-only` prints a one-line CI-friendly summary.
+- **Interactive review TUI overhaul**:
+  - multi-pane layout with filters, selection state, detail panel, and status bar,
+  - risk/security/peer/license context inline per package,
+  - explicit selection controls for interactive upgrade review.
+- **Additive output contract metadata**:
+  - summary fields: `verdict`, `riskPackages`, `securityPackages`, `peerConflictPackages`, `licenseViolationPackages`, `interactiveSession`,
+  - GitHub outputs: `verdict`, `risk_packages`, `security_packages`, `peer_conflict_packages`, `license_violation_packages`,
+  - SARIF result properties for impact/risk/advisory/license context.
+- **New display controls**:
+  - `--interactive`
+  - `--show-impact`
+  - `--show-homepage`
+- **RC3 hardening layer on top of GA surfaces**:
+  - centralized classified error taxonomy in `src/core/errors.ts`,
+  - compatibility coverage for scoped private registries and cache backend fallback,
+  - explicit cache fallback reason reporting for SQLite → file cache degradation,
+  - dedicated performance scenarios for `check`, `resolve`, and `ci`,
+  - new comparison document: `docs/why-rainy-vs-dependabot-renovate.md`.
+
+### Changed
+
+- `check` now computes impact scores in the core pipeline and carries homepage metadata when available.
+- `upgrade --interactive` now routes through the guided review flow before applying selected updates.
+- CLI help and package exports now cover the new review/verdict surfaces.
+- `doctor` output now follows the RC3 quick-verdict shape:
+  - `State`
+  - `PrimaryRisk`
+  - `NextAction`
+- `check`, `warm-cache`, and `audit` now emit RC3-style classified warnings/errors for:
+  - registry failures,
+  - auth failures,
+  - advisory-source degradation/outage,
+  - cache backend fallback.
+
+### Tests
+
+- Added compatibility tests for:
+  - scoped `.npmrc` private registry resolution,
+  - forced cache backend fallback behavior.
+- Updated audit coverage to assert the new classified advisory degradation warning format.
+
 ## [0.5.2-rc.2] - 2026-02-27
 
 ### Added

package/README.md

@@ -1,16 +1,65 @@
 # @rainy-updates/cli
 
-The fastest DevOps-first dependency CLI. Checks, audits, upgrades, bisects, and automates npm/pnpm dependencies in CI.
+Rainy Updates is a deterministic dependency review and upgrade operator for Node monorepos and CI.
 
-`@rainy-updates/cli` is built for teams that need fast dependency intelligence, security auditing, policy-aware upgrades, and automation-ready output for CI/CD and pull request workflows.
+`@rainy-updates/cli` is built for teams that need fast dependency detection, trustworthy review, controlled upgrades, and automation-ready outputs for CI/CD.
 
-## Why this package
+Comparison:
+[Why Rainy vs Dependabot and Renovate](./docs/why-rainy-vs-dependabot-renovate.md)
+
+Command model:
+[Check → Doctor → Review → Upgrade](./docs/command-model.md)
+
+Review workflow:
+[Review workflow guide](./docs/review-workflow.md)
+
+Risk engine:
+[Risk engine guide](./docs/risk-engine.md)
+
+Benchmarks:
+[Benchmark methodology](./docs/benchmarks.md)
+
+## What it is
+
+Rainy Updates gives teams one dependency lifecycle:
+
+- `check` detects candidate updates.
+- `doctor` summarizes the current situation.
+- `review` decides what should happen.
+- `upgrade` applies the approved change set.
+
+Everything else supports that lifecycle: CI orchestration, advisory lookup, peer resolution, licenses, snapshots, baselines, and fix-PR automation.
+
+## Who it is for
+
+- Node monorepo teams that want deterministic CI artifacts.
+- Engineers who want to review dependency risk locally before applying changes.
+- Teams that need fewer, better upgrade decisions instead of noisy automated PR churn.
+
+## 60-second workflow
+
+```bash
+# 1) Detect what changed
+npx @rainy-updates/cli check --workspace --show-impact
+
+# 2) Summarize what matters
+npx @rainy-updates/cli doctor --workspace
+
+# 3) Decide in the review surface
+npx @rainy-updates/cli review --interactive
+
+# 4) Apply the approved set
+npx @rainy-updates/cli upgrade --interactive
+```
+
+## Why teams use it
 
 - Detects updates quickly across single-package repos and workspaces.
+- Centralizes security, peer, license, health, and behavioral risk review.
 - Applies updates safely with configurable targets (`patch`, `minor`, `major`, `latest`).
-- Enforces policy rules per package (ignore rules and max upgrade level).
+- Enforces policy rules per package.
 - Supports offline and cache-warmed execution for deterministic CI runs.
-- Produces machine-readable artifacts (JSON, SARIF, GitHub outputs, PR markdown report).
+- Produces machine-readable artifacts: JSON, SARIF, GitHub outputs, and PR reports.
 
 ## Install
 
@@ -49,10 +98,15 @@ npx @rainy-updates/cli ci --workspace --mode strict
 
 ## Commands
 
-### Dependency management
+### Primary workflow
+
+- `check` — detect candidate dependency updates
+- `doctor` — summarize the current dependency situation
+- `review` — decide what to do with security, risk, peer, and policy context
+- `upgrade` — apply the approved change set
+
+### Supporting workflow
 
-- `check` — analyze dependencies and report available updates
-- `upgrade` — rewrite dependency ranges in manifests, optionally install lockfile updates
 - `ci` — run CI-focused dependency automation (warm cache, check/upgrade, policy gates)
 - `warm-cache` — prefetch package metadata for fast and offline checks
 - `baseline` — save and compare dependency baseline snapshots
@@ -72,31 +126,35 @@ npx @rainy-updates/cli ci --workspace --mode strict
 npx @rainy-updates/cli check --format table
 rup check --format table                      # if installed
 
-# 2) Strict CI mode (non-zero when updates exist)
-npx @rainy-updates/cli check --workspace --ci --format json --json-file .artifacts/updates.json
-rup check --workspace --ci --format json --json-file .artifacts/updates.json
+# 2) Summarize the state
+npx @rainy-updates/cli doctor --workspace
+rup doctor --workspace
 
-# 3) CI orchestration with policy gates
+# 3) Review and decide
+npx @rainy-updates/cli review --security-only
+rup review --interactive
+
+# 4) Apply upgrades with workspace sync
+npx @rainy-updates/cli upgrade --target latest --workspace --sync --install
+rup upgrade --target latest --workspace --sync --install
+
+# 5) CI orchestration with policy gates
 npx @rainy-updates/cli ci --workspace --mode strict --format github
 rup ci --workspace --mode strict --format github
 
-# 4) Batch fix branches by scope (enterprise)
+# 6) Batch fix branches by scope (enterprise)
 npx @rainy-updates/cli ci --workspace --mode enterprise --group-by scope --fix-pr --fix-pr-batch-size 2
 rup ci --workspace --mode enterprise --group-by scope --fix-pr --fix-pr-batch-size 2
 
-# 5) Apply upgrades with workspace sync
-npx @rainy-updates/cli upgrade --target latest --workspace --sync --install
-rup upgrade --target latest --workspace --sync --install
-
-# 6) Warm cache → deterministic offline CI check
+# 7) Warm cache → deterministic offline CI check
 npx @rainy-updates/cli warm-cache --workspace --concurrency 32
 npx @rainy-updates/cli check --workspace --offline --ci
 
-# 7) Save and compare baseline drift
+# 8) Save and compare baseline drift
 npx @rainy-updates/cli baseline --save --file .artifacts/deps-baseline.json --workspace
 npx @rainy-updates/cli baseline --check --file .artifacts/deps-baseline.json --workspace --ci
 
-# 8) Scan for known CVEs  ── NEW in v0.5.1
+# 9) Scan for known CVEs
 npx @rainy-updates/cli audit
 npx @rainy-updates/cli audit --severity high
 npx @rainy-updates/cli audit --summary
@@ -106,17 +164,20 @@ rup audit --severity high                   # if installed
 
 `audit` prefers npm/pnpm lockfiles today for exact installed-version inference, and now also reads simple `bun.lock` workspace entries when available. It reports source-health warnings when OSV or GitHub returns only partial coverage.
 
-# 9) Check dependency maintenance health  ── NEW in v0.5.1
+# 10) Check dependency maintenance health
 npx @rainy-updates/cli health
 npx @rainy-updates/cli health --stale 6m   # flag packages with no release in 6 months
 npx @rainy-updates/cli health --stale 180d # same but in days
 rup health --stale 6m                       # if installed
 
-# 10) Find which version introduced a breaking change  ── NEW in v0.5.1
+# 11) Find which version introduced a breaking change
 npx @rainy-updates/cli bisect axios --cmd "bun test"
 npx @rainy-updates/cli bisect react --range "18.0.0..19.0.0" --cmd "npm test"
 npx @rainy-updates/cli bisect lodash --cmd "npm run test:unit" --dry-run
 rup bisect axios --cmd "bun test"           # if installed
+
+# 12) Focus review on high-risk changes
+rup review --risk high --diff major
 ```
 
 ## What it does in production
@@ -129,6 +190,7 @@ rup bisect axios --cmd "bun test"           # if installed
 - Supports explicit registry retry/timeout tuning (`--registry-retries`, `--registry-timeout-ms`).
 - Supports stale-cache fallback when registry calls fail.
 - Supports streamed progress output for long CI runs (`--stream`).
+- Exposes impact/risk metadata and homepage context in update output (`--show-impact`, `--show-homepage`).
 
 ### Workspace support
 
@@ -170,6 +232,13 @@ npx @rainy-updates/cli check --policy-file .rainyupdates-policy.json
 - `--format table`
 - `--format minimal`
 
+Review-centered outputs:
+
+- `check` is optimized for detection.
+- `doctor` is optimized for summary.
+- `review` is optimized for decision-making.
+- `upgrade` is optimized for safe application.
+
 ### Automation output
 
 - `--format json`
@@ -229,6 +298,9 @@ Schedule:
 - `--cooldown-days <n>`
 - `--pr-limit <n>`
 - `--only-changed`
+- `--interactive`
+- `--show-impact`
+- `--show-homepage`
 - `--mode minimal|strict|enterprise` (for `ci`)
 - `--fix-pr-batch-size <n>` (for batched fix branches in `ci`)
 - `--policy-file <path>`
@@ -251,6 +323,17 @@ Schedule:
 - `--pm auto|npm|pnpm`
 - `--sync`
 
+### Review-only
+
+- `--security-only`
+- `--risk critical|high|medium|low`
+- `--diff patch|minor|major|latest`
+- `--apply-selected`
+
+### Doctor-only
+
+- `--verdict-only`
+
 ### Baseline-only
 
 - `--save`

package/dist/bin/cli.js

@@ -85,7 +85,7 @@ async function main() {
             process.exitCode = result.totalFlagged > 0 ? 1 : 0;
             return;
         }
-        // ─── v0.5.2 commands ─────────────────────────────────────────────────────
+        // ─── v0.5.3 commands ─────────────────────────────────────────────────────
         if (parsed.command === "unused") {
             const { runUnused } = await import("../commands/unused/runner.js");
             const result = await runUnused(parsed.options);
@@ -111,6 +111,39 @@ async function main() {
             process.exitCode = result.errors.length > 0 ? 1 : 0;
             return;
         }
+        if (parsed.command === "review") {
+            const { runReview } = await import("../commands/review/runner.js");
+            const result = await runReview(parsed.options);
+            process.exitCode =
+                result.summary.verdict === "blocked" ||
+                    result.summary.verdict === "actionable" ||
+                    result.summary.verdict === "review"
+                    ? 1
+                    : 0;
+            return;
+        }
+        if (parsed.command === "doctor") {
+            const { runDoctor } = await import("../commands/doctor/runner.js");
+            const result = await runDoctor(parsed.options);
+            process.exitCode = result.verdict === "safe" ? 0 : 1;
+            return;
+        }
+        if (parsed.options.interactive &&
+            (parsed.command === "check" ||
+                parsed.command === "upgrade" ||
+                parsed.command === "ci")) {
+            const { runReview } = await import("../commands/review/runner.js");
+            const result = await runReview({
+                ...parsed.options,
+                securityOnly: false,
+                risk: undefined,
+                diff: undefined,
+                applySelected: parsed.command === "upgrade",
+            });
+            process.exitCode =
+                result.summary.verdict === "safe" && result.updates.length === 0 ? 0 : 1;
+            return;
+        }
         const result = await runCommand(parsed);
         if (parsed.options.fixPr &&
             (parsed.command === "check" ||
@@ -148,11 +181,17 @@ async function main() {
         }
         result.summary.failReason = resolveFailReason(result.updates, result.errors, parsed.options.failOn, parsed.options.maxUpdates, parsed.options.ci);
         const renderStartedAt = Date.now();
-        let rendered = renderResult(result, parsed.options.format);
+        let rendered = renderResult(result, parsed.options.format, {
+            showImpact: parsed.options.showImpact,
+            showHomepage: parsed.options.showHomepage,
+        });
         result.summary.durationMs.render = Math.max(0, Date.now() - renderStartedAt);
         if (parsed.options.format === "json" ||
             parsed.options.format === "metrics") {
-            rendered = renderResult(result, parsed.options.format);
+            rendered = renderResult(result, parsed.options.format, {
+                showImpact: parsed.options.showImpact,
+                showHomepage: parsed.options.showHomepage,
+            });
         }
         if (parsed.options.onlyChanged &&
             result.updates.length === 0 &&
@@ -187,7 +226,11 @@ function renderHelp(command) {
     if (isCommand && command === "check") {
         return `rainy-updates check [options]
 
-Detect available dependency updates.
+Detect candidate dependency updates. This is the first step in the flow:
+  check detects
+  doctor summarizes
+  review decides
+  upgrade applies
 
 Options:
   --workspace
@@ -220,6 +263,9 @@ Options:
   --cooldown-days <n>
   --pr-limit <n>
   --only-changed
+  --interactive
+  --show-impact
+  --show-homepage
   --lockfile-mode preserve|update|error
   --log-level error|warn|info|debug
   --ci`;
@@ -249,7 +295,7 @@ Options:
     if (isCommand && command === "upgrade") {
         return `rainy-updates upgrade [options]
 
-Apply dependency updates to package.json manifests.
+Apply an approved change set to package.json manifests.
 
 Options:
   --workspace
@@ -267,6 +313,7 @@ Options:
   --fix-dry-run
   --fix-pr-no-checkout
   --fix-pr-batch-size <n>
+  --interactive
   --lockfile-mode preserve|update|error
   --no-pr-report
   --json-file <path>
@@ -275,7 +322,11 @@ Options:
     if (isCommand && command === "ci") {
         return `rainy-updates ci [options]
 
-Run CI-oriented dependency automation pipeline.
+Run CI-oriented automation around the same lifecycle:
+  check detects
+  doctor summarizes
+  review decides
+  upgrade applies
 
 Options:
   --workspace
@@ -349,13 +400,44 @@ Options:
   --json-file <path>
   --concurrency <n>
   --registry-timeout-ms <n>`;
+    }
+    if (isCommand && command === "review") {
+        return `rainy-updates review [options]
+
+Review is the decision center of Rainy Updates.
+Use it to inspect risk, security, peer, license, and policy context before applying changes.
+
+Options:
+  --workspace
+  --interactive
+  --security-only
+  --risk critical|high|medium|low
+  --diff patch|minor|major|latest
+  --apply-selected
+  --policy-file <path>
+  --json-file <path>
+  --concurrency <n>
+  --registry-timeout-ms <n>
+  --registry-retries <n>`;
+    }
+    if (isCommand && command === "doctor") {
+        return `rainy-updates doctor [options]
+
+Produce a fast summary verdict and point the operator to review when action is needed.
+
+Options:
+  --workspace
+  --verdict-only
+  --json-file <path>`;
     }
     return `rainy-updates (rup / rainy-up) <command> [options]
 
 Commands:
-  check       Detect available updates
-  upgrade     Apply updates to manifests
-  ci          Run CI-focused update pipeline
+  check       Detect candidate updates
+  doctor      Summarize what matters
+  review      Decide what to do
+  upgrade     Apply the approved change set
+  ci          Run CI-focused orchestration
   warm-cache  Warm local cache for fast/offline checks
   init-ci     Scaffold GitHub Actions workflow
   baseline    Save/check dependency baseline snapshots
@@ -384,6 +466,9 @@ Global options:
   --cooldown-days <n>
   --pr-limit <n>
   --only-changed
+  --interactive
+  --show-impact
+  --show-homepage
   --mode minimal|strict|enterprise
   --fix-pr
   --fix-branch <name>
@@ -405,6 +490,36 @@ Global options:
   --version, -v`;
 }
 async function runCommand(parsed) {
+    if (parsed.command === "review") {
+        const { runReview } = await import("../commands/review/runner.js");
+        const result = await runReview(parsed.options);
+        return {
+            projectPath: result.projectPath,
+            packagePaths: result.items.map((item) => item.update.packagePath),
+            packageManager: "unknown",
+            target: result.target,
+            timestamp: new Date().toISOString(),
+            summary: result.summary,
+            updates: result.updates,
+            errors: result.errors,
+            warnings: result.warnings,
+        };
+    }
+    if (parsed.command === "doctor") {
+        const { runDoctor } = await import("../commands/doctor/runner.js");
+        const result = await runDoctor(parsed.options);
+        return {
+            projectPath: result.review.projectPath,
+            packagePaths: result.review.items.map((item) => item.update.packagePath),
+            packageManager: "unknown",
+            target: result.review.target,
+            timestamp: new Date().toISOString(),
+            summary: result.summary,
+            updates: result.review.updates,
+            errors: result.review.errors,
+            warnings: result.review.warnings,
+        };
+    }
     if (parsed.command === "upgrade") {
         return await upgrade(parsed.options);
     }

package/dist/cache/cache.d.ts

@@ -3,6 +3,7 @@ export declare class VersionCache {
     private readonly store;
     readonly backend: "sqlite" | "file";
     readonly degraded: boolean;
+    readonly fallbackReason?: string;
     private constructor();
     static create(customPath?: string): Promise<VersionCache>;
     getValid(packageName: string, target: TargetLevel): Promise<CachedVersion | null>;

package/dist/cache/cache.js

@@ -1,6 +1,7 @@
 import { promises as fs } from "node:fs";
 import os from "node:os";
 import path from "node:path";
+import process from "node:process";
 class FileCacheStore {
     filePath;
     constructor(filePath) {
@@ -108,20 +109,26 @@ export class VersionCache {
     store;
     backend;
     degraded;
-    constructor(store, backend, degraded) {
+    fallbackReason;
+    constructor(store, backend, degraded, fallbackReason) {
         this.store = store;
         this.backend = backend;
         this.degraded = degraded;
+        this.fallbackReason = fallbackReason;
     }
     static async create(customPath) {
         const basePath = customPath ?? path.join(os.homedir(), ".cache", "rainy-updates");
+        if (process.env.RAINY_UPDATES_CACHE_BACKEND === "file") {
+            const jsonPath = path.join(basePath, "cache.json");
+            return new VersionCache(new FileCacheStore(jsonPath), "file", true, "forced via RAINY_UPDATES_CACHE_BACKEND=file");
+        }
         const sqlitePath = path.join(basePath, "cache.db");
         const sqliteStore = await tryCreateSqliteStore(sqlitePath);
         if (sqliteStore)
             return new VersionCache(sqliteStore, "sqlite", false);
         const jsonPath = path.join(basePath, "cache.json");
         const degraded = typeof Bun !== "undefined";
-        return new VersionCache(new FileCacheStore(jsonPath), "file", degraded);
+        return new VersionCache(new FileCacheStore(jsonPath), "file", degraded, degraded ? "bun:sqlite unavailable; using file cache backend" : undefined);
     }
     async getValid(packageName, target) {
         const entry = await this.store.get(packageName, target);

package/dist/commands/audit/runner.js

@@ -8,6 +8,7 @@ import { stableStringify } from "../../utils/stable-json.js";
 import { fetchAdvisories } from "./fetcher.js";
 import { resolveAuditTargets } from "./targets.js";
 import { filterBySeverity, buildPatchMap, renderAuditSourceHealth, renderAuditSummary, renderAuditTable, summarizeAdvisories, } from "./mapper.js";
+import { formatClassifiedMessage } from "../../core/errors.js";
 /**
  * Entry point for `rup audit`. Lazy-loaded by cli.ts.
  * Discovers packages, fetches CVE advisories, filters by severity, and
@@ -63,7 +64,13 @@ export async function runAudit(options) {
     result.sourceHealth = fetched.sourceHealth;
     result.warnings.push(...fetched.warnings);
     if (fetched.sourceHealth.every((item) => item.status === "failed")) {
-        result.errors.push("All advisory sources failed. Audit coverage is unavailable for this run.");
+        result.errors.push(formatClassifiedMessage({
+            code: "ADVISORY_SOURCE_DOWN",
+            whatFailed: "All advisory sources failed.",
+            intact: "Dependency target resolution completed, but no advisory coverage was returned.",
+            validity: "invalid",
+            next: "Retry `rup audit` later or select a single healthy source with --source.",
+        }));
     }
     let advisories = fetched.advisories;
     advisories = filterBySeverity(advisories, options.severity);

package/dist/commands/audit/sources/index.js

@@ -1,6 +1,7 @@
 import { compareVersions, parseVersion } from "../../../utils/semver.js";
 import { githubAuditSource } from "./github.js";
 import { osvAuditSource } from "./osv.js";
+import { formatClassifiedMessage } from "../../../core/errors.js";
 const SOURCE_MAP = {
     osv: osvAuditSource,
     github: githubAuditSource,
@@ -62,7 +63,13 @@ function normalizeSourceWarnings(warnings, sourceHealth) {
         const successfulNames = successful
             .map((item) => formatSourceName(item.source))
             .join(", ");
-        normalized.push(`Continuing with partial advisory coverage: ${failedNames} failed, ${successfulNames} still returned results.`);
+        normalized.push(formatClassifiedMessage({
+            code: "ADVISORY_SOURCE_DEGRADED",
+            whatFailed: `${failedNames} advisory source(s) failed during the audit query.`,
+            intact: `${successfulNames} still returned advisory results.`,
+            validity: "partial",
+            next: "Retry `rup audit` later or pin `--source` to a healthy backend.",
+        }));
     }
     return normalized;
 }

package/dist/commands/doctor/parser.d.ts

@@ -0,0 +1,2 @@
+import type { DoctorOptions } from "../../types/index.js";
+export declare function parseDoctorArgs(args: string[]): DoctorOptions;