@rainy-updates/cli 0.5.6 → 0.6.0

package/dist/commands/licenses/runner.js

@@ -1,9 +1,9 @@
-import process from "node:process";
 import { discoverPackageDirs } from "../../workspace/discover.js";
 import { readManifest, collectDependencies, } from "../../parsers/package-json.js";
 import { asyncPool } from "../../utils/async-pool.js";
 import { stableStringify } from "../../utils/stable-json.js";
 import { writeFileAtomic } from "../../utils/io.js";
+import { writeStderr, writeStdout } from "../../utils/runtime.js";
 import { generateSbom } from "./sbom.js";
 /**
  * Entry point for `rup licenses`. Lazy-loaded by cli.ts.
@@ -63,17 +63,17 @@ export async function runLicenses(options) {
     }
     result.totalViolations = result.violations.length;
     // Render
-    process.stdout.write(renderLicenseTable(result) + "\n");
+    writeStdout(renderLicenseTable(result) + "\n");
     // SBOM output
     if (options.sbomFile) {
         const sbom = generateSbom(result.packages, options.cwd);
         await writeFileAtomic(options.sbomFile, stableStringify(sbom, 2) + "\n");
-        process.stderr.write(`[licenses] SBOM written to ${options.sbomFile}\n`);
+        writeStderr(`[licenses] SBOM written to ${options.sbomFile}\n`);
     }
     // JSON output
     if (options.jsonFile) {
         await writeFileAtomic(options.jsonFile, stableStringify(result, 2) + "\n");
-        process.stderr.write(`[licenses] JSON report written to ${options.jsonFile}\n`);
+        writeStderr(`[licenses] JSON report written to ${options.jsonFile}\n`);
     }
     return result;
 }

package/dist/commands/resolve/runner.js

@@ -1,8 +1,8 @@
-import process from "node:process";
 import { buildPeerGraph } from "./graph/builder.js";
 import { resolvePeerConflicts } from "./graph/resolver.js";
 import { stableStringify } from "../../utils/stable-json.js";
 import { writeFileAtomic } from "../../utils/io.js";
+import { writeStderr, writeStdout } from "../../utils/runtime.js";
 /**
  * Entry point for `rup resolve`. Lazy-loaded by cli.ts.
  *
@@ -26,7 +26,7 @@ export async function runResolve(options) {
     if (options.afterUpdate) {
         versionOverrides = await fetchProposedVersions(options);
         if (versionOverrides.size === 0 && !options.silent) {
-            process.stderr.write("[resolve] No pending updates found — checking current state.\n");
+            writeStderr("[resolve] No pending updates found — checking current state.\n");
         }
     }
     let graph;
@@ -42,12 +42,12 @@ export async function runResolve(options) {
     result.errorConflicts = conflicts.filter((c) => c.severity === "error").length;
     result.warningConflicts = conflicts.filter((c) => c.severity === "warning").length;
     if (!options.silent) {
-        process.stdout.write(renderConflictsTable(result, options) + "\n");
+        writeStdout(renderConflictsTable(result, options) + "\n");
     }
     if (options.jsonFile) {
         await writeFileAtomic(options.jsonFile, stableStringify(result, 2) + "\n");
         if (!options.silent) {
-            process.stderr.write(`[resolve] JSON report written to ${options.jsonFile}\n`);
+            writeStderr(`[resolve] JSON report written to ${options.jsonFile}\n`);
         }
     }
     return result;
@@ -100,6 +100,11 @@ async function fetchProposedVersions(options) {
             interactive: false,
             showImpact: false,
             showHomepage: false,
+            decisionPlanFile: undefined,
+            verify: "none",
+            testCommand: undefined,
+            verificationReportFile: undefined,
+            ciGate: "check",
         });
         for (const update of checkResult.updates ?? []) {
             overrides.set(update.name, update.toVersionResolved);

package/dist/commands/review/parser.js

@@ -1,9 +1,9 @@
 import path from "node:path";
-import process from "node:process";
 import { ensureRiskLevel } from "../../core/options.js";
+import { exitProcess, getRuntimeCwd, writeStdout, } from "../../utils/runtime.js";
 export function parseReviewArgs(args) {
     const options = {
-        cwd: process.cwd(),
+        cwd: getRuntimeCwd(),
         target: "latest",
         filter: undefined,
         reject: undefined,
@@ -47,6 +47,12 @@ export function parseReviewArgs(args) {
         diff: undefined,
         applySelected: false,
         showChangelog: false,
+        decisionPlanFile: undefined,
+        queueFocus: "all",
+        verify: "none",
+        testCommand: undefined,
+        verificationReportFile: undefined,
+        ciGate: "check",
     };
     for (let i = 0; i < args.length; i += 1) {
         const current = args[i];
@@ -94,6 +100,41 @@ export function parseReviewArgs(args) {
             options.applySelected = true;
             continue;
         }
+        if (current === "--plan-file" && next) {
+            options.decisionPlanFile = path.resolve(options.cwd, next);
+            i += 1;
+            continue;
+        }
+        if (current === "--plan-file")
+            throw new Error("Missing value for --plan-file");
+        if (current === "--verify" && next) {
+            if (next === "none" ||
+                next === "install" ||
+                next === "test" ||
+                next === "install,test") {
+                options.verify = next;
+                i += 1;
+                continue;
+            }
+            throw new Error("--verify must be none, install, test or install,test");
+        }
+        if (current === "--verify")
+            throw new Error("Missing value for --verify");
+        if (current === "--test-command" && next) {
+            options.testCommand = next;
+            i += 1;
+            continue;
+        }
+        if (current === "--test-command")
+            throw new Error("Missing value for --test-command");
+        if (current === "--verification-report-file" && next) {
+            options.verificationReportFile = path.resolve(options.cwd, next);
+            i += 1;
+            continue;
+        }
+        if (current === "--verification-report-file") {
+            throw new Error("Missing value for --verification-report-file");
+        }
         if (current === "--show-changelog") {
             options.showChangelog = true;
             continue;
@@ -148,13 +189,22 @@ export function parseReviewArgs(args) {
             throw new Error("Missing value for --registry-retries");
         }
         if (current === "--help" || current === "-h") {
-            process.stdout.write(REVIEW_HELP);
-            process.exit(0);
+            writeStdout(REVIEW_HELP);
+            exitProcess(0);
         }
         if (current.startsWith("-"))
             throw new Error(`Unknown review option: ${current}`);
         throw new Error(`Unexpected review argument: ${current}`);
     }
+    if (options.securityOnly) {
+        options.queueFocus = "security";
+    }
+    else if (options.risk === "critical" || options.risk === "high") {
+        options.queueFocus = "risk";
+    }
+    else if (options.diff === "major") {
+        options.queueFocus = "major";
+    }
     return options;
 }
 const REVIEW_HELP = `
@@ -169,6 +219,9 @@ Options:
   --risk <level>          Minimum risk: critical, high, medium, low
   --diff <level>          Filter by patch, minor, major, latest
   --apply-selected        Apply all filtered updates after review
+  --plan-file <path>      Write the selected decision set to a reusable plan file
+  --verify <mode>         Run post-apply verification: none, install, test, install,test
+  --test-command <cmd>    Override the command used for test verification
   --show-changelog        Fetch release notes summaries for review output
   --workspace             Scan all workspace packages
   --policy-file <path>    Load policy overrides

package/dist/commands/review/runner.js

@@ -1,16 +1,42 @@
-import process from "node:process";
-import { runTui } from "../../ui/tui.js";
 import { buildReviewResult, renderReviewResult } from "../../core/review-model.js";
 import { applySelectedUpdates } from "../../core/upgrade.js";
+import { createDecisionPlan, writeDecisionPlan } from "../../core/decision-plan.js";
 import { stableStringify } from "../../utils/stable-json.js";
 import { writeFileAtomic } from "../../utils/io.js";
+import { writeStdout } from "../../utils/runtime.js";
 export async function runReview(options) {
     const review = await buildReviewResult(options);
-    let selectedItems = review.items;
     if (options.interactive && review.updates.length > 0) {
-        selectedItems = await runTui(review.items);
+        const { runDashboard } = await import("../dashboard/runner.js");
+        const dashboard = await runDashboard({
+            ...options,
+            mode: options.applySelected ? "upgrade" : "review",
+            focus: options.queueFocus ?? "all",
+            applySelected: options.applySelected,
+        }, review);
+        review.summary.decisionPlan = dashboard.decisionPlanFile;
+        review.summary.interactiveSurface = "dashboard";
+        review.summary.queueFocus = options.queueFocus ?? "all";
+        if (options.jsonFile) {
+            await writeFileAtomic(options.jsonFile, stableStringify(review, 2) + "\n");
+        }
+        return review;
     }
+    let selectedItems = review.items;
     const selectedUpdates = selectedItems.map((item) => item.update);
+    if (options.decisionPlanFile) {
+        const decisionPlan = createDecisionPlan({
+            review,
+            selectedItems,
+            sourceCommand: "review",
+            mode: options.applySelected ? "upgrade" : "review",
+            focus: options.queueFocus ?? "all",
+        });
+        const decisionPlanFile = options.decisionPlanFile;
+        await writeDecisionPlan(decisionPlanFile, decisionPlan);
+        review.decisionPlan = decisionPlan;
+        review.summary.decisionPlan = decisionPlanFile;
+    }
     if (options.applySelected && selectedUpdates.length > 0) {
         await applySelectedUpdates({
             ...options,
@@ -19,7 +45,7 @@ export async function runReview(options) {
             sync: false,
         }, selectedUpdates);
     }
-    process.stdout.write(renderReviewResult({
+    writeStdout(renderReviewResult({
         ...review,
         items: selectedItems,
         updates: selectedUpdates,

package/dist/commands/snapshot/runner.js

@@ -1,6 +1,6 @@
-import process from "node:process";
 import { discoverPackageDirs } from "../../workspace/discover.js";
 import { SnapshotStore, captureState, restoreState, diffManifests, } from "./store.js";
+import { writeStderr, writeStdout } from "../../utils/runtime.js";
 /**
  * Entry point for `rup snapshot`. Lazy-loaded by cli.ts.
  *
@@ -27,7 +27,7 @@ export async function runSnapshot(options) {
             const entry = await store.saveSnapshot(manifests, lockfileHashes, label);
             result.snapshotId = entry.id;
             result.label = entry.label;
-            process.stdout.write(`✔ Snapshot saved: ${entry.label} (${entry.id})\n`);
+            writeStdout(`✔ Snapshot saved: ${entry.label} (${entry.id})\n`);
             break;
         }
         // ─ list ──────────────────────────────────────────────────────────────────
@@ -39,20 +39,20 @@ export async function runSnapshot(options) {
                 createdAt: new Date(e.createdAt).toISOString(),
             }));
             if (entries.length === 0) {
-                process.stdout.write("No snapshots saved yet. Use `rup snapshot save` to create one.\n");
+                writeStdout("No snapshots saved yet. Use `rup snapshot save` to create one.\n");
             }
             else {
-                process.stdout.write(`\n${entries.length} snapshot(s):\n\n`);
-                process.stdout.write("  " + "ID".padEnd(30) + "Label".padEnd(30) + "Created\n");
-                process.stdout.write("  " + "─".repeat(75) + "\n");
+                writeStdout(`\n${entries.length} snapshot(s):\n\n`);
+                writeStdout("  " + "ID".padEnd(30) + "Label".padEnd(30) + "Created\n");
+                writeStdout("  " + "─".repeat(75) + "\n");
                 for (const e of entries) {
-                    process.stdout.write("  " +
+                    writeStdout("  " +
                         e.id.padEnd(30) +
                         e.label.padEnd(30) +
                         new Date(e.createdAt).toLocaleString() +
                         "\n");
                 }
-                process.stdout.write("\n");
+                writeStdout("\n");
             }
             break;
         }
@@ -72,8 +72,8 @@ export async function runSnapshot(options) {
             result.snapshotId = entry.id;
             result.label = entry.label;
             const count = Object.keys(entry.manifests).length;
-            process.stdout.write(`✔ Restored ${count} package.json file(s) from snapshot "${entry.label}" (${entry.id})\n`);
-            process.stdout.write("  Re-run your package manager install to apply.\n");
+            writeStdout(`✔ Restored ${count} package.json file(s) from snapshot "${entry.label}" (${entry.id})\n`);
+            writeStdout("  Re-run your package manager install to apply.\n");
             break;
         }
         // ─ diff ──────────────────────────────────────────────────────────────────
@@ -92,23 +92,23 @@ export async function runSnapshot(options) {
             const changes = diffManifests(entry.manifests, currentManifests);
             result.diff = changes;
             if (changes.length === 0) {
-                process.stdout.write(`✔ No dependency changes since snapshot "${entry.label}"\n`);
+                writeStdout(`✔ No dependency changes since snapshot "${entry.label}"\n`);
             }
             else {
-                process.stdout.write(`\nDependency changes since snapshot "${entry.label}":\n\n`);
-                process.stdout.write("  " + "Package".padEnd(35) + "Before".padEnd(20) + "After\n");
-                process.stdout.write("  " + "─".repeat(65) + "\n");
+                writeStdout(`\nDependency changes since snapshot "${entry.label}":\n\n`);
+                writeStdout("  " + "Package".padEnd(35) + "Before".padEnd(20) + "After\n");
+                writeStdout("  " + "─".repeat(65) + "\n");
                 for (const c of changes) {
-                    process.stdout.write("  " + c.name.padEnd(35) + c.from.padEnd(20) + c.to + "\n");
+                    writeStdout("  " + c.name.padEnd(35) + c.from.padEnd(20) + c.to + "\n");
                 }
-                process.stdout.write("\n");
+                writeStdout("\n");
             }
             break;
         }
     }
     if (result.errors.length > 0) {
         for (const err of result.errors) {
-            process.stderr.write(`[snapshot] ✖ ${err}\n`);
+            writeStderr(`[snapshot] ✖ ${err}\n`);
         }
     }
     return result;

package/dist/commands/snapshot/store.d.ts

@@ -1,13 +1,4 @@
 import type { SnapshotEntry } from "../../types/index.js";
-/**
- * Lightweight SQLite-free snapshot store (uses a JSON file in the project root).
- *
- * Design goals:
- *   - No extra runtime dependencies (SQLite bindings vary by runtime)
- *   - Human-readable store file (git-committable if desired)
- *   - Atomic writes via tmp-rename to prevent corruption
- *   - Fast: entire store fits in memory for typical use (< 50 snapshots)
- */
 export declare class SnapshotStore {
     private readonly storePath;
     private entries;
@@ -20,14 +11,11 @@ export declare class SnapshotStore {
     findSnapshot(idOrLabel: string): Promise<SnapshotEntry | null>;
     deleteSnapshot(idOrLabel: string): Promise<boolean>;
 }
-/** Captures current package.json and lockfile state for a set of directories. */
 export declare function captureState(packageDirs: string[]): Promise<{
     manifests: Record<string, string>;
     lockfileHashes: Record<string, string>;
 }>;
-/** Restores package.json files from a snapshot's manifest map. */
 export declare function restoreState(entry: SnapshotEntry): Promise<void>;
-/** Computes a diff of dependency versions between two manifest snapshots. */
 export declare function diffManifests(before: Record<string, string>, after: Record<string, string>): Array<{
     name: string;
     from: string;

package/dist/commands/snapshot/store.js

@@ -1,16 +1,6 @@
-import { createHash } from "node:crypto";
-import { promises as fs } from "node:fs";
 import path from "node:path";
+import { writeFileAtomic } from "../../utils/io.js";
 const DEFAULT_STORE_NAME = ".rup-snapshots.json";
-/**
- * Lightweight SQLite-free snapshot store (uses a JSON file in the project root).
- *
- * Design goals:
- *   - No extra runtime dependencies (SQLite bindings vary by runtime)
- *   - Human-readable store file (git-committable if desired)
- *   - Atomic writes via tmp-rename to prevent corruption
- *   - Fast: entire store fits in memory for typical use (< 50 snapshots)
- */
 export class SnapshotStore {
     storePath;
     entries = [];
@@ -26,8 +16,7 @@ export class SnapshotStore {
         if (this.loaded)
             return;
         try {
-            const raw = await fs.readFile(this.storePath, "utf8");
-            const parsed = JSON.parse(raw);
+            const parsed = (await Bun.file(this.storePath).json());
             if (Array.isArray(parsed)) {
                 this.entries = parsed;
             }
@@ -38,9 +27,7 @@ export class SnapshotStore {
         this.loaded = true;
     }
     async save() {
-        const tmp = this.storePath + ".tmp";
-        await fs.writeFile(tmp, JSON.stringify(this.entries, null, 2) + "\n", "utf8");
-        await fs.rename(tmp, this.storePath);
+        await writeFileAtomic(this.storePath, JSON.stringify(this.entries, null, 2) + "\n");
     }
     async saveSnapshot(manifests, lockfileHashes, label) {
         await this.load();
@@ -76,32 +63,30 @@ export class SnapshotStore {
         return false;
     }
 }
-/** Captures current package.json and lockfile state for a set of directories. */
 export async function captureState(packageDirs) {
     const manifests = {};
     const lockfileHashes = {};
-    const LOCKFILES = [
+    const lockfiles = [
         "package-lock.json",
         "pnpm-lock.yaml",
         "yarn.lock",
+        "bun.lock",
         "bun.lockb",
     ];
     await Promise.all(packageDirs.map(async (dir) => {
-        // Read package.json
         try {
-            const content = await fs.readFile(path.join(dir, "package.json"), "utf8");
-            manifests[dir] = content;
+            manifests[dir] = await Bun.file(path.join(dir, "package.json")).text();
         }
         catch {
             // No package.json — skip
         }
-        // Hash the first lockfile found
-        for (const lf of LOCKFILES) {
+        for (const lockfileName of lockfiles) {
+            const filePath = path.join(dir, lockfileName);
             try {
-                const content = await fs.readFile(path.join(dir, lf));
-                lockfileHashes[dir] = createHash("sha256")
-                    .update(content)
-                    .digest("hex");
+                const file = Bun.file(filePath);
+                if (!(await file.exists()))
+                    continue;
+                lockfileHashes[dir] = await hashFile(filePath);
                 break;
             }
             catch {
@@ -111,16 +96,11 @@ export async function captureState(packageDirs) {
     }));
     return { manifests, lockfileHashes };
 }
-/** Restores package.json files from a snapshot's manifest map. */
 export async function restoreState(entry) {
     await Promise.all(Object.entries(entry.manifests).map(async ([dir, content]) => {
-        const manifestPath = path.join(dir, "package.json");
-        const tmp = manifestPath + ".tmp";
-        await fs.writeFile(tmp, content, "utf8");
-        await fs.rename(tmp, manifestPath);
+        await writeFileAtomic(path.join(dir, "package.json"), content);
     }));
 }
-/** Computes a diff of dependency versions between two manifest snapshots. */
 export function diffManifests(before, after) {
     const changes = [];
     for (const [dir, afterJson] of Object.entries(after)) {
@@ -142,12 +122,15 @@ export function diffManifests(before, after) {
             "optionalDependencies",
         ];
         for (const field of fields) {
-            const before = beforeManifest[field] ?? {};
-            const after = afterManifest[field] ?? {};
-            const allNames = new Set([...Object.keys(before), ...Object.keys(after)]);
+            const beforeDeps = beforeManifest[field] ?? {};
+            const afterDeps = afterManifest[field] ?? {};
+            const allNames = new Set([
+                ...Object.keys(beforeDeps),
+                ...Object.keys(afterDeps),
+            ]);
             for (const name of allNames) {
-                const fromVer = before[name] ?? "(removed)";
-                const toVer = after[name] ?? "(removed)";
+                const fromVer = beforeDeps[name] ?? "(removed)";
+                const toVer = afterDeps[name] ?? "(removed)";
                 if (fromVer !== toVer) {
                     changes.push({ name, from: fromVer, to: toVer });
                 }
@@ -156,3 +139,8 @@ export function diffManifests(before, after) {
     }
     return changes;
 }
+async function hashFile(filePath) {
+    const hasher = new Bun.CryptoHasher("sha256");
+    hasher.update(await Bun.file(filePath).bytes());
+    return hasher.digest("hex");
+}

package/dist/commands/unused/runner.js

@@ -1,9 +1,9 @@
 import path from "node:path";
-import process from "node:process";
 import { readManifest, } from "../../parsers/package-json.js";
 import { discoverPackageDirs } from "../../workspace/discover.js";
 import { writeFileAtomic } from "../../utils/io.js";
 import { stableStringify } from "../../utils/stable-json.js";
+import { writeStderr, writeStdout } from "../../utils/runtime.js";
 import { scanDirectory } from "./scanner.js";
 import { matchDependencies, removeUnusedFromManifest } from "./matcher.js";
 /**
@@ -60,16 +60,15 @@ export async function runUnused(options) {
         // ─ Apply fix ─────────────────────────────────────────────────────────────
         if (options.fix && unused.length > 0) {
             if (options.dryRun) {
-                process.stderr.write(`[unused] --dry-run: would remove ${unused.length} unused dep(s) from ${packageDir}/package.json\n`);
+                writeStderr(`[unused] --dry-run: would remove ${unused.length} unused dep(s) from ${packageDir}/package.json\n`);
             }
             else {
                 try {
-                    const { promises: fs } = await import("node:fs");
                     const manifestPath = path.join(packageDir, "package.json");
-                    const originalJson = await fs.readFile(manifestPath, "utf8");
+                    const originalJson = await Bun.file(manifestPath).text();
                     const updatedJson = removeUnusedFromManifest(originalJson, unused);
                     await writeFileAtomic(manifestPath, updatedJson);
-                    process.stderr.write(`[unused] Removed ${unused.length} unused dep(s) from ${packageDir}/package.json\n`);
+                    writeStderr(`[unused] Removed ${unused.length} unused dep(s) from ${packageDir}/package.json\n`);
                 }
                 catch (error) {
                     result.errors.push(`Failed to update package.json in ${packageDir}: ${String(error)}`);
@@ -80,11 +79,11 @@ export async function runUnused(options) {
     result.totalUnused = result.unused.length;
     result.totalMissing = result.missing.length;
     // ─ Render output ─────────────────────────────────────────────────────────
-    process.stdout.write(renderUnusedTable(result) + "\n");
+    writeStdout(renderUnusedTable(result) + "\n");
     // ─ JSON report ───────────────────────────────────────────────────────────
     if (options.jsonFile) {
         await writeFileAtomic(options.jsonFile, stableStringify(result, 2) + "\n");
-        process.stderr.write(`[unused] JSON report written to ${options.jsonFile}\n`);
+        writeStderr(`[unused] JSON report written to ${options.jsonFile}\n`);
     }
     return result;
 }

package/dist/commands/unused/scanner.js

@@ -93,34 +93,31 @@ export async function scanDirectory(dir) {
 async function walkDirectory(dir, collector) {
     let entries;
     try {
-        entries = await fs.readdir(dir);
+        entries = await fs.readdir(dir, { withFileTypes: true });
     }
     catch {
         return;
     }
     const tasks = [];
-    for (const entryName of entries) {
+    for (const entry of entries) {
+        const entryName = entry.name;
         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);
+        if (entry.isDirectory()) {
+            tasks.push(walkDirectory(fullPath, collector));
+            continue;
+        }
+        if (!entry.isFile())
+            continue;
+        const ext = path.extname(entryName).toLowerCase();
+        if (!SOURCE_EXTENSIONS.has(ext))
+            continue;
+        tasks.push(Bun.file(fullPath)
+            .text()
+            .then((source) => {
+            for (const name of extractImportsFromSource(source)) {
+                collector.add(name);
             }
         })
             .catch(() => undefined));

package/dist/config/loader.d.ts

@@ -1,4 +1,4 @@
-import type { CiProfile, DependencyKind, FailOnLevel, GroupBy, LockfileMode, LogLevel, OutputFormat, TargetLevel } from "../types/index.js";
+import type { CiProfile, SelectedPackageManager, DependencyKind, FailOnLevel, GroupBy, LockfileMode, LogLevel, OutputFormat, TargetLevel } from "../types/index.js";
 export interface FileConfig {
     target?: TargetLevel;
     filter?: string;
@@ -39,7 +39,7 @@ export interface FileConfig {
     showImpact?: boolean;
     showHomepage?: boolean;
     install?: boolean;
-    packageManager?: "auto" | "npm" | "pnpm";
+    packageManager?: SelectedPackageManager;
     sync?: boolean;
 }
 export declare function loadConfig(cwd: string): Promise<FileConfig>;

package/dist/config/loader.js

@@ -1,4 +1,3 @@
-import { promises as fs } from "node:fs";
 import path from "node:path";
 export async function loadConfig(cwd) {
     const fromRc = await loadRcFile(cwd);
@@ -13,8 +12,7 @@ async function loadRcFile(cwd) {
     for (const candidate of candidates) {
         const filePath = path.join(cwd, candidate);
         try {
-            const content = await fs.readFile(filePath, "utf8");
-            return JSON.parse(content);
+            return (await Bun.file(filePath).json());
         }
         catch {
             // noop
@@ -25,8 +23,7 @@ async function loadRcFile(cwd) {
 async function loadPackageConfig(cwd) {
     const packagePath = path.join(cwd, "package.json");
     try {
-        const content = await fs.readFile(packagePath, "utf8");
-        const parsed = JSON.parse(content);
+        const parsed = (await Bun.file(packagePath).json());
         return parsed.rainyUpdates ?? {};
     }
     catch {