@rainy-updates/cli 0.5.7 → 0.6.1

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/parser.js

@@ -3,6 +3,11 @@ export function parseUnusedArgs(args) {
     const options = {
         cwd: process.cwd(),
         workspace: false,
+        affected: false,
+        staged: false,
+        baseRef: undefined,
+        headRef: undefined,
+        sinceRef: undefined,
         srcDirs: DEFAULT_SRC_DIRS,
         includeDevDependencies: true,
         fix: false,
@@ -24,6 +29,35 @@ export function parseUnusedArgs(args) {
             options.workspace = true;
             continue;
         }
+        if (current === "--affected") {
+            options.affected = true;
+            continue;
+        }
+        if (current === "--staged") {
+            options.staged = true;
+            continue;
+        }
+        if (current === "--base" && next) {
+            options.baseRef = next;
+            i++;
+            continue;
+        }
+        if (current === "--base")
+            throw new Error("Missing value for --base");
+        if (current === "--head" && next) {
+            options.headRef = next;
+            i++;
+            continue;
+        }
+        if (current === "--head")
+            throw new Error("Missing value for --head");
+        if (current === "--since" && next) {
+            options.sinceRef = next;
+            i++;
+            continue;
+        }
+        if (current === "--since")
+            throw new Error("Missing value for --since");
         if (current === "--src" && next) {
             options.srcDirs = next
                 .split(",")
@@ -81,6 +115,11 @@ Usage:
 Options:
   --src <dirs>          Comma-separated source directories to scan (default: src)
   --workspace           Scan all workspace packages
+  --affected            Scan changed workspace packages and their dependents
+  --staged              Limit scanning to staged changes
+  --base <ref>          Compare changes against a base git ref
+  --head <ref>          Compare changes against a head git ref
+  --since <ref>         Compare changes since a git ref
   --no-dev              Exclude devDependencies from unused detection
   --fix                 Remove unused dependencies from package.json
   --dry-run             Preview changes without writing

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";
 /**
@@ -24,7 +24,10 @@ export async function runUnused(options) {
         errors: [],
         warnings: [],
     };
-    const packageDirs = await discoverPackageDirs(options.cwd, options.workspace);
+    const packageDirs = await discoverPackageDirs(options.cwd, options.workspace, {
+        git: options,
+        includeDependents: false,
+    });
     for (const packageDir of packageDirs) {
         // ─ Read manifest ─────────────────────────────────────────────────────────
         let manifest;
@@ -60,16 +63,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 +82,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.d.ts

@@ -1,10 +1,11 @@
 /**
- * Extracts all imported package names from a single source file.
+ * Extracts all imported package names from a single source file using AST.
  *
  * Handles:
  *   - ESM static:  import ... from "pkg"
  *   - ESM dynamic: import("pkg")
  *   - CJS:         require("pkg")
+ *   - ESM re-export: export ... from "pkg"
  *
  * Strips subpath imports (e.g. "lodash/merge" → "lodash"),
  * skips relative imports and node: builtins.

package/dist/commands/unused/scanner.js

@@ -1,37 +1,63 @@
-import { promises as fs } from "node:fs";
 import path from "node:path";
+import { parseSync } from "oxc-parser";
 /**
- * Extracts all imported package names from a single source file.
+ * Extracts all imported package names from a single source file using AST.
  *
  * Handles:
  *   - ESM static:  import ... from "pkg"
  *   - ESM dynamic: import("pkg")
  *   - CJS:         require("pkg")
+ *   - ESM re-export: export ... from "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]);
+    try {
+        const parseResult = parseSync("unknown.ts", source, {
+            sourceType: "module",
+        });
+        const walk = (node) => {
+            if (!node)
+                return;
+            if (node.type === "ImportDeclaration" && node.source?.value) {
+                addPackageName(names, node.source.value);
+            }
+            else if (node.type === "ExportNamedDeclaration" && node.source?.value) {
+                addPackageName(names, node.source.value);
+            }
+            else if (node.type === "ExportAllDeclaration" && node.source?.value) {
+                addPackageName(names, node.source.value);
+            }
+            else if (node.type === "ImportExpression" && node.source?.value) {
+                addPackageName(names, node.source.value);
+            }
+            else if (node.type === "CallExpression") {
+                if (node.callee?.type === "Identifier" &&
+                    node.callee.name === "require" &&
+                    node.arguments?.[0]?.type === "StringLiteral") {
+                    addPackageName(names, node.arguments[0].value);
+                }
+            }
+            // Traverse children
+            for (const key in node) {
+                if (node[key] && typeof node[key] === "object") {
+                    if (Array.isArray(node[key])) {
+                        for (const child of node[key]) {
+                            walk(child);
+                        }
+                    }
+                    else {
+                        walk(node[key]);
+                    }
+                }
+            }
+        };
+        walk(parseResult.program);
     }
-    // export ... from "pkg"
-    const reExport = /\bexport\s+(?:\*|\{[^}]*\})\s+from\s+['"]([^'"]+)['"]/g;
-    for (const match of source.matchAll(reExport)) {
-        addPackageName(names, match[1]);
+    catch (err) {
+        // Fallback or ignore parse errors
     }
     return names;
 }
@@ -87,43 +113,30 @@ const IGNORED_DIRS = new Set([
  */
 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 glob = new Bun.Glob("**/*.{ts,tsx,js,jsx,mjs,cjs,mts,cts}");
     const tasks = [];
-    for (const entryName of entries) {
-        if (IGNORED_DIRS.has(entryName))
+    for await (const file of glob.scan(dir)) {
+        // Bun.Glob returns relative paths
+        const fullPath = path.join(dir, file);
+        // Quick check to ignore certain directories in the path
+        if (fullPath.includes("/node_modules/") ||
+            fullPath.includes("/.git/") ||
+            fullPath.includes("/dist/") ||
+            fullPath.includes("/build/") ||
+            fullPath.includes("/out/") ||
+            fullPath.includes("/.next/") ||
+            fullPath.includes("/.nuxt/")) {
             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);
+        }
+        tasks.push(Bun.file(fullPath)
+            .text()
+            .then((source) => {
+            for (const name of extractImportsFromSource(source)) {
+                allImports.add(name);
             }
         })
             .catch(() => undefined));
     }
     await Promise.all(tasks);
+    return allImports;
 }

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 {

package/dist/config/policy.js

@@ -1,19 +1,24 @@
-import { promises as fs } from "node:fs";
 import path from "node:path";
 export async function loadPolicy(cwd, policyFile) {
-    const candidates = policyFile ? [policyFile] : [
-        path.join(cwd, ".rainyupdates-policy.json"),
-        path.join(cwd, "rainy-updates.policy.json"),
-    ];
+    const candidates = policyFile
+        ? [policyFile]
+        : [
+            path.join(cwd, ".rainyupdates-policy.json"),
+            path.join(cwd, "rainy-updates.policy.json"),
+        ];
     for (const candidate of candidates) {
-        const filePath = path.isAbsolute(candidate) ? candidate : path.resolve(cwd, candidate);
+        const filePath = path.isAbsolute(candidate)
+            ? candidate
+            : path.resolve(cwd, candidate);
         try {
-            const content = await fs.readFile(filePath, "utf8");
-            const parsed = JSON.parse(content);
+            const parsed = (await Bun.file(filePath).json());
             return {
                 ignorePatterns: parsed.ignore ?? [],
                 cooldownDays: asNonNegativeInt(parsed.cooldownDays),
-                packageRules: new Map(Object.entries(parsed.packageRules ?? {}).map(([pkg, rule]) => [pkg, normalizeRule(rule)])),
+                packageRules: new Map(Object.entries(parsed.packageRules ?? {}).map(([pkg, rule]) => [
+                    pkg,
+                    normalizeRule(rule),
+                ])),
                 matchRules: Object.values(parsed.packageRules ?? {})
                     .map((rule) => normalizeRule(rule))
                     .filter((rule) => typeof rule.match === "string" && rule.match.length > 0),
@@ -44,7 +49,9 @@ function normalizeRule(rule) {
         maxUpdatesPerRun: asNonNegativeInt(rule.maxUpdatesPerRun),
         cooldownDays: asNonNegativeInt(rule.cooldownDays),
         allowPrerelease: rule.allowPrerelease === true,
-        group: typeof rule.group === "string" && rule.group.trim().length > 0 ? rule.group.trim() : undefined,
+        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,
@@ -60,7 +67,9 @@ function matchesPattern(value, pattern) {
         return false;
     if (pattern === "*")
         return true;
-    const escaped = pattern.replace(/[.+^${}()|[\]\\]/g, "\\$&").replace(/\*/g, ".*");
+    const escaped = pattern
+        .replace(/[.+^${}()|[\]\\]/g, "\\$&")
+        .replace(/\*/g, ".*");
     const regex = new RegExp(`^${escaped}$`);
     return regex.test(value);
 }

package/dist/core/analysis/run-silenced.js

@@ -1,4 +1,3 @@
-import process from "node:process";
 export async function runSilenced(fn) {
     const stdoutWrite = process.stdout.write.bind(process.stdout);
     const stderrWrite = process.stderr.write.bind(process.stderr);

package/dist/core/artifacts.js

@@ -1,10 +1,9 @@
-import crypto from "node:crypto";
 import path from "node:path";
 import { stableStringify } from "../utils/stable-json.js";
 import { writeFileAtomic } from "../utils/io.js";
 export function createRunId(command, options, result) {
-    const hash = crypto.createHash("sha256");
-    hash.update(stableStringify({
+    const hasher = new Bun.CryptoHasher("sha256");
+    hasher.update(stableStringify({
         command,
         cwd: path.resolve(options.cwd),
         target: options.target,
@@ -17,14 +16,15 @@ export function createRunId(command, options, result) {
             toRange: update.toRange,
         })),
     }, 0));
-    return hash.digest("hex").slice(0, 16);
+    return hasher.digest("hex").slice(0, 16);
 }
 export async function writeArtifactManifest(command, options, result) {
     const shouldWrite = options.ci ||
         Boolean(options.jsonFile) ||
         Boolean(options.githubOutputFile) ||
         Boolean(options.sarifFile) ||
-        Boolean(options.prReportFile);
+        Boolean(options.prReportFile) ||
+        Boolean(options.verificationReportFile);
     if (!shouldWrite)
         return null;
     const runId = result.summary.runId ?? createRunId(command, options, result);
@@ -41,6 +41,7 @@ export async function writeArtifactManifest(command, options, result) {
             githubOutputFile: options.githubOutputFile,
             sarifFile: options.sarifFile,
             prReportFile: options.prReportFile,
+            verificationReportFile: options.verificationReportFile,
         },
     };
     await writeFileAtomic(artifactManifestPath, stableStringify(manifest, 2) + "\n");

package/dist/core/baseline.js

@@ -1,6 +1,6 @@
-import { promises as fs } from "node:fs";
 import path from "node:path";
 import { collectDependencies, readManifest } from "../parsers/package-json.js";
+import { writeFileAtomic } from "../utils/io.js";
 import { discoverPackageDirs } from "../workspace/discover.js";
 export async function saveBaseline(options) {
     const entries = await collectBaselineEntries(options.cwd, options.workspace, options.includeKinds);
@@ -9,16 +9,14 @@ export async function saveBaseline(options) {
         createdAt: new Date().toISOString(),
         entries,
     };
-    await fs.mkdir(path.dirname(options.filePath), { recursive: true });
-    await fs.writeFile(options.filePath, JSON.stringify(payload, null, 2) + "\n", "utf8");
+    await writeFileAtomic(options.filePath, JSON.stringify(payload, null, 2) + "\n");
     return {
         filePath: options.filePath,
         entries: entries.length,
     };
 }
 export async function diffBaseline(options) {
-    const content = await fs.readFile(options.filePath, "utf8");
-    const baseline = JSON.parse(content);
+    const baseline = (await Bun.file(options.filePath).json());
     const currentEntries = await collectBaselineEntries(options.cwd, options.workspace, options.includeKinds);
     const baselineMap = new Map(baseline.entries.map((entry) => [toKey(entry), entry]));
     const currentMap = new Map(currentEntries.map((entry) => [toKey(entry), entry]));

package/dist/core/check.js

@@ -1,5 +1,4 @@
 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";
@@ -11,6 +10,7 @@ import { loadPolicy, resolvePolicyRule } from "../config/policy.js";
 import { createSummary, finalizeSummary } from "./summary.js";
 import { applyImpactScores } from "./impact.js";
 import { formatClassifiedMessage } from "./errors.js";
+import { writeStdout } from "../utils/runtime.js";
 export async function check(options) {
     const startedAt = Date.now();
     let discoveryMs = 0;
@@ -18,7 +18,11 @@ export async function check(options) {
     let registryMs = 0;
     const discoveryStartedAt = Date.now();
     const packageManager = await detectPackageManager(options.cwd);
-    const packageDirs = await discoverPackageDirs(options.cwd, options.workspace);
+    const packageDirs = await discoverPackageDirs(options.cwd, options.workspace, {
+        git: options,
+        includeKinds: options.includeKinds,
+        includeDependents: options.affected === true,
+    });
     discoveryMs += Date.now() - discoveryStartedAt;
     const cache = await VersionCache.create();
     const registryClient = new NpmRegistryClient(options.cwd, {
@@ -48,7 +52,7 @@ export async function check(options) {
         if (!options.stream)
             return;
         streamedEvents += 1;
-        process.stdout.write(`${message}\n`);
+        writeStdout(`${message}\n`);
     };
     for (const packageDir of packageDirs) {
         let manifest;