@rainy-updates/cli 0.5.7 → 0.6.1

package/dist/git/scope.js

@@ -0,0 +1,167 @@
+import path from "node:path";
+import { readManifest } from "../parsers/package-json.js";
+import { buildWorkspaceGraph } from "../workspace/graph.js";
+export function hasGitScope(options) {
+    return (options.onlyChanged === true ||
+        options.affected === true ||
+        options.staged === true ||
+        typeof options.baseRef === "string" ||
+        typeof options.headRef === "string" ||
+        typeof options.sinceRef === "string");
+}
+export async function scopePackageDirsByGit(cwd, packageDirs, options, config = {}) {
+    if (!hasGitScope(options)) {
+        return {
+            packageDirs,
+            warnings: [],
+            changedFiles: [],
+        };
+    }
+    const changedFiles = await listChangedFiles(cwd, options);
+    if ("warnings" in changedFiles) {
+        return {
+            packageDirs,
+            warnings: changedFiles.warnings,
+            changedFiles: [],
+        };
+    }
+    const changedPackageDirs = mapFilesToPackageDirs(cwd, packageDirs, changedFiles.files);
+    if (changedPackageDirs.length === 0) {
+        return {
+            packageDirs: [],
+            warnings: [],
+            changedFiles: changedFiles.files,
+        };
+    }
+    if (!config.includeDependents) {
+        return {
+            packageDirs: changedPackageDirs,
+            warnings: [],
+            changedFiles: changedFiles.files,
+        };
+    }
+    const affectedPackageDirs = await expandToDependents(changedPackageDirs, packageDirs, config.includeKinds ?? ["dependencies", "devDependencies"]);
+    return {
+        packageDirs: affectedPackageDirs,
+        warnings: [],
+        changedFiles: changedFiles.files,
+    };
+}
+async function listChangedFiles(cwd, options) {
+    const primaryArgs = buildGitDiffArgs(options);
+    const diff = await runGit(cwd, primaryArgs);
+    if (!diff.ok) {
+        return {
+            warnings: [
+                `Git scope could not be resolved (${diff.error}). Falling back to full workspace scan.`,
+            ],
+        };
+    }
+    const untracked = await runGit(cwd, ["ls-files", "--others", "--exclude-standard"]);
+    const files = new Set();
+    for (const value of [...diff.lines, ...(untracked.ok ? untracked.lines : [])]) {
+        const trimmed = value.trim();
+        if (trimmed.length === 0)
+            continue;
+        files.add(trimmed);
+    }
+    return {
+        files: Array.from(files).sort((left, right) => left.localeCompare(right)),
+    };
+}
+function buildGitDiffArgs(options) {
+    if (options.staged) {
+        return ["diff", "--name-only", "--cached"];
+    }
+    if (options.baseRef && options.headRef) {
+        return ["diff", "--name-only", `${options.baseRef}...${options.headRef}`];
+    }
+    if (options.baseRef) {
+        return ["diff", "--name-only", `${options.baseRef}...HEAD`];
+    }
+    if (options.sinceRef) {
+        return ["diff", "--name-only", `${options.sinceRef}..HEAD`];
+    }
+    return ["diff", "--name-only", "HEAD"];
+}
+async function runGit(cwd, args) {
+    try {
+        const proc = Bun.spawn(["git", ...args], {
+            cwd,
+            stdout: "pipe",
+            stderr: "pipe",
+        });
+        const [stdout, stderr, exitCode] = await Promise.all([
+            new Response(proc.stdout).text(),
+            new Response(proc.stderr).text(),
+            proc.exited,
+        ]);
+        if (exitCode !== 0) {
+            const message = stderr.trim() || `git ${args.join(" ")} exited with code ${exitCode}`;
+            return { ok: false, error: message };
+        }
+        return {
+            ok: true,
+            lines: stdout.split(/\r?\n/).filter(Boolean),
+        };
+    }
+    catch (error) {
+        return { ok: false, error: String(error) };
+    }
+}
+function mapFilesToPackageDirs(cwd, packageDirs, files) {
+    const sortedDirs = [...packageDirs].sort((left, right) => right.length - left.length);
+    const matched = new Set();
+    for (const file of files) {
+        const absoluteFile = path.resolve(cwd, file);
+        let bestMatch;
+        for (const packageDir of sortedDirs) {
+            const relative = path.relative(packageDir, absoluteFile);
+            if (relative === "" || (!relative.startsWith("..") && !path.isAbsolute(relative))) {
+                bestMatch = packageDir;
+                break;
+            }
+        }
+        if (bestMatch) {
+            matched.add(bestMatch);
+        }
+    }
+    return Array.from(matched).sort((left, right) => left.localeCompare(right));
+}
+async function expandToDependents(changedPackageDirs, packageDirs, includeKinds) {
+    const manifestsByPath = new Map();
+    for (const packageDir of packageDirs) {
+        try {
+            manifestsByPath.set(packageDir, await readManifest(packageDir));
+        }
+        catch {
+            // Skip unreadable manifests; callers already handle manifest read failures.
+        }
+    }
+    const graph = buildWorkspaceGraph(manifestsByPath, includeKinds);
+    const pathByName = new Map(graph.nodes.map((node) => [node.packageName, node.packagePath]));
+    const nameByPath = new Map(graph.nodes.map((node) => [node.packagePath, node.packageName]));
+    const dependents = new Map();
+    for (const node of graph.nodes) {
+        for (const dependency of node.dependsOn) {
+            const list = dependents.get(dependency) ?? [];
+            list.push(node.packageName);
+            dependents.set(dependency, list);
+        }
+    }
+    const selected = new Set(changedPackageDirs);
+    const queue = changedPackageDirs
+        .map((packageDir) => nameByPath.get(packageDir))
+        .filter((value) => typeof value === "string");
+    while (queue.length > 0) {
+        const current = queue.shift();
+        for (const dependent of dependents.get(current) ?? []) {
+            const dependentPath = pathByName.get(dependent);
+            if (!dependentPath || selected.has(dependentPath))
+                continue;
+            selected.add(dependentPath);
+            queue.push(dependent);
+        }
+    }
+    return Array.from(selected).sort((left, right) => left.localeCompare(right));
+}

package/dist/index.d.ts

@@ -4,9 +4,10 @@ export { warmCache } from "./core/warm-cache.js";
 export { runCi } from "./core/ci.js";
 export { initCiWorkflow } from "./core/init-ci.js";
 export { saveBaseline, diffBaseline } from "./core/baseline.js";
+export { runHook } from "./commands/hook/runner.js";
 export { createSarifReport } from "./output/sarif.js";
 export { writeGitHubOutput, renderGitHubAnnotations } from "./output/github.js";
 export { renderPrReport } from "./output/pr-report.js";
 export { buildReviewResult, createDoctorResult } from "./core/review-model.js";
 export { applyRiskAssessments } from "./risk/index.js";
-export type { CheckOptions, CheckResult, CiProfile, DependencyKind, FailOnLevel, GroupBy, OutputFormat, PackageUpdate, RunOptions, TargetLevel, UpgradeOptions, UpgradeResult, ReviewOptions, ReviewResult, DoctorOptions, DoctorResult, Verdict, RiskLevel, RiskCategory, RiskAssessment, RiskFactor, MaintainerChurnStatus, } from "./types/index.js";
+export type { CheckOptions, CheckResult, CiProfile, DependencyKind, FailOnLevel, GroupBy, OutputFormat, PackageUpdate, RunOptions, TargetLevel, UpgradeOptions, UpgradeResult, ReviewOptions, ReviewResult, DoctorOptions, DoctorResult, HookOptions, HookResult, Verdict, RiskLevel, RiskCategory, RiskAssessment, RiskFactor, MaintainerChurnStatus, } from "./types/index.js";

package/dist/index.js

@@ -4,6 +4,7 @@ export { warmCache } from "./core/warm-cache.js";
 export { runCi } from "./core/ci.js";
 export { initCiWorkflow } from "./core/init-ci.js";
 export { saveBaseline, diffBaseline } from "./core/baseline.js";
+export { runHook } from "./commands/hook/runner.js";
 export { createSarifReport } from "./output/sarif.js";
 export { writeGitHubOutput, renderGitHubAnnotations } from "./output/github.js";
 export { renderPrReport } from "./output/pr-report.js";

package/dist/output/format.js

@@ -74,6 +74,12 @@ export function renderResult(result, format, display = {}) {
             `primary_finding_code=${result.summary.primaryFindingCode ?? ""}`,
             `primary_finding_category=${result.summary.primaryFindingCategory ?? ""}`,
             `next_action_reason=${result.summary.nextActionReason ?? ""}`,
+            `suggested_command=${result.summary.suggestedCommand ?? ""}`,
+            `decision_plan=${result.summary.decisionPlan ?? ""}`,
+            `interactive_surface=${result.summary.interactiveSurface ?? ""}`,
+            `queue_focus=${result.summary.queueFocus ?? ""}`,
+            `verification_state=${result.summary.verificationState ?? "not-run"}`,
+            `verification_failures=${result.summary.verificationFailures ?? 0}`,
         ].join("\n");
     }
     const lines = [];
@@ -137,6 +143,15 @@ export function renderResult(result, format, display = {}) {
     if (typeof result.summary.dependencyHealthScore === "number") {
         lines.push(`DependencyHealthScore=${result.summary.dependencyHealthScore}, primaryFinding=${result.summary.primaryFindingCode ?? "none"}, category=${result.summary.primaryFindingCategory ?? "none"}`);
     }
+    if (result.summary.suggestedCommand) {
+        lines.push(`SuggestedCommand=${result.summary.suggestedCommand}`);
+    }
+    if (result.summary.decisionPlan) {
+        lines.push(`DecisionPlan=${result.summary.decisionPlan}, surface=${result.summary.interactiveSurface ?? "none"}, focus=${result.summary.queueFocus ?? "all"}`);
+    }
+    if (result.summary.verificationState && result.summary.verificationState !== "not-run") {
+        lines.push(`Verification=${result.summary.verificationState}, failures=${result.summary.verificationFailures ?? 0}`);
+    }
     if (result.summary.runId) {
         lines.push(`RunId=${result.summary.runId}, artifactManifest=${result.summary.artifactManifest ?? "none"}, blockedPackages=${result.summary.blockedPackages ?? 0}, reviewPackages=${result.summary.reviewPackages ?? 0}, monitorPackages=${result.summary.monitorPackages ?? 0}`);
     }

package/dist/output/github.js

@@ -38,6 +38,12 @@ export async function writeGitHubOutput(filePath, result) {
         `primary_finding_code=${result.summary.primaryFindingCode ?? ""}`,
         `primary_finding_category=${result.summary.primaryFindingCategory ?? ""}`,
         `next_action_reason=${result.summary.nextActionReason ?? ""}`,
+        `suggested_command=${result.summary.suggestedCommand ?? ""}`,
+        `decision_plan=${result.summary.decisionPlan ?? ""}`,
+        `interactive_surface=${result.summary.interactiveSurface ?? ""}`,
+        `queue_focus=${result.summary.queueFocus ?? ""}`,
+        `verification_state=${result.summary.verificationState ?? "not-run"}`,
+        `verification_failures=${result.summary.verificationFailures ?? 0}`,
         `fix_pr_applied=${result.summary.fixPrApplied === true ? "1" : "0"}`,
         `fix_pr_branches_created=${result.summary.fixPrBranchesCreated}`,
         `fix_pr_branch=${result.summary.fixBranchName ?? ""}`,

package/dist/output/sarif.js

@@ -1,6 +1,4 @@
-import { readFileSync } from "node:fs";
-import path from "node:path";
-import { fileURLToPath } from "node:url";
+import { CLI_VERSION } from "../generated/version.js";
 export function createSarifReport(result) {
     const dependencyRuleId = "rainy-updates/dependency-update";
     const runtimeRuleId = "rainy-updates/runtime-error";
@@ -46,7 +44,9 @@ export function createSarifReport(result) {
             runId: result.summary.runId,
         },
     }));
-    const errorResults = [...result.errors].sort((a, b) => a.localeCompare(b)).map((error) => ({
+    const errorResults = [...result.errors]
+        .sort((a, b) => a.localeCompare(b))
+        .map((error) => ({
         ruleId: runtimeRuleId,
         level: "error",
         message: {
@@ -66,12 +66,16 @@ export function createSarifReport(result) {
                             {
                                 id: dependencyRuleId,
                                 shortDescription: { text: "Dependency update available" },
-                                fullDescription: { text: "A dependency has a newer version according to configured target." },
+                                fullDescription: {
+                                    text: "A dependency has a newer version according to configured target.",
+                                },
                             },
                             {
                                 id: runtimeRuleId,
                                 shortDescription: { text: "Dependency resolution error" },
-                                fullDescription: { text: "The resolver could not fetch or parse package metadata." },
+                                fullDescription: {
+                                    text: "The resolver could not fetch or parse package metadata.",
+                                },
                             },
                         ],
                     },
@@ -114,16 +118,6 @@ let TOOL_VERSION_CACHE = null;
 function getToolVersion() {
     if (TOOL_VERSION_CACHE)
         return TOOL_VERSION_CACHE;
-    try {
-        const currentFile = fileURLToPath(import.meta.url);
-        const packageJsonPath = path.resolve(path.dirname(currentFile), "../../package.json");
-        const content = readFileSync(packageJsonPath, "utf8");
-        const parsed = JSON.parse(content);
-        TOOL_VERSION_CACHE = parsed.version ?? "0.0.0";
-        return TOOL_VERSION_CACHE;
-    }
-    catch {
-        TOOL_VERSION_CACHE = "0.0.0";
-        return TOOL_VERSION_CACHE;
-    }
+    TOOL_VERSION_CACHE = CLI_VERSION;
+    return TOOL_VERSION_CACHE;
 }

package/dist/parsers/package-json.js

@@ -1,4 +1,3 @@
-import { promises as fs } from "node:fs";
 import path from "node:path";
 const DEPENDENCY_KINDS = [
     "dependencies",
@@ -11,13 +10,12 @@ export function getPackageJsonPath(cwd) {
 }
 export async function readManifest(cwd) {
     const filePath = getPackageJsonPath(cwd);
-    const content = await fs.readFile(filePath, "utf8");
-    return JSON.parse(content);
+    return (await Bun.file(filePath).json());
 }
 export async function writeManifest(cwd, manifest) {
     const filePath = getPackageJsonPath(cwd);
     const content = JSON.stringify(manifest, null, 2) + "\n";
-    await fs.writeFile(filePath, content, "utf8");
+    await Bun.write(filePath, content);
 }
 export function collectDependencies(manifest, includeKinds) {
     const deps = [];

package/dist/pm/detect.d.ts

@@ -1 +1,40 @@
-export declare function detectPackageManager(cwd: string): Promise<"npm" | "pnpm" | "unknown">;
+import type { DetectedPackageManager, SelectedPackageManager, SupportedPackageManager } from "../types/index.js";
+export type PackageManagerDetectionSource = "packageManager-field" | "lockfile" | "fallback";
+export type YarnFlavor = "classic" | "berry" | "unknown";
+export interface PackageManagerDetection {
+    manager: DetectedPackageManager;
+    source: PackageManagerDetectionSource;
+    lockfile?: string;
+    packageManagerField?: string;
+    yarnFlavor?: YarnFlavor;
+}
+export interface PackageManagerProfile {
+    manager: SupportedPackageManager;
+    command: SupportedPackageManager;
+    source: PackageManagerDetectionSource;
+    lockfile?: string;
+    packageManagerField?: string;
+    yarnFlavor?: YarnFlavor;
+}
+export declare function detectPackageManager(cwd: string): Promise<DetectedPackageManager>;
+export declare function detectPackageManagerDetails(cwd: string): Promise<PackageManagerDetection>;
+export declare function resolvePackageManager(requested: SelectedPackageManager, detected: DetectedPackageManager, fallback?: SupportedPackageManager): SupportedPackageManager;
+export declare function resolvePackageManagerProfile(cwd: string, requested: SelectedPackageManager, fallback?: SupportedPackageManager): Promise<PackageManagerProfile>;
+export declare function createPackageManagerProfile(requested: SelectedPackageManager, detected: PackageManagerDetection, fallback?: SupportedPackageManager): PackageManagerProfile;
+export declare function buildInstallInvocation(profile: PackageManagerProfile, options?: {
+    frozen?: boolean;
+    ci?: boolean;
+}): {
+    command: string;
+    args: string[];
+    display: string;
+};
+export declare function buildAddInvocation(profile: PackageManagerProfile, packages: string[], options?: {
+    exact?: boolean;
+    noSave?: boolean;
+}): {
+    command: string;
+    args: string[];
+    display: string;
+};
+export declare function buildTestCommand(profile: PackageManagerProfile): string;

package/dist/pm/detect.js

@@ -1,20 +1,163 @@
-import { access } from "node:fs/promises";
 import path from "node:path";
+const PACKAGE_MANAGER_LOCKFILES = [
+    ["bun.lock", "bun"],
+    ["bun.lockb", "bun"],
+    ["pnpm-lock.yaml", "pnpm"],
+    ["package-lock.json", "npm"],
+    ["npm-shrinkwrap.json", "npm"],
+    ["yarn.lock", "yarn"],
+];
 export async function detectPackageManager(cwd) {
-    const pnpmLock = path.join(cwd, "pnpm-lock.yaml");
-    const npmLock = path.join(cwd, "package-lock.json");
+    return (await detectPackageManagerDetails(cwd)).manager;
+}
+export async function detectPackageManagerDetails(cwd) {
+    const packageManagerField = await readPackageManagerField(cwd);
+    if (packageManagerField) {
+        const parsed = parsePackageManagerField(packageManagerField);
+        if (parsed) {
+            return {
+                manager: parsed.manager,
+                source: "packageManager-field",
+                packageManagerField,
+                yarnFlavor: parsed.yarnFlavor,
+            };
+        }
+    }
+    for (const [lockfile, packageManager] of PACKAGE_MANAGER_LOCKFILES) {
+        if (await fileExists(path.join(cwd, lockfile))) {
+            return {
+                manager: packageManager,
+                source: "lockfile",
+                lockfile,
+                yarnFlavor: packageManager === "yarn" ? "unknown" : undefined,
+            };
+        }
+    }
+    return {
+        manager: "unknown",
+        source: "fallback",
+        packageManagerField: packageManagerField ?? undefined,
+    };
+}
+export function resolvePackageManager(requested, detected, fallback = "npm") {
+    if (requested !== "auto")
+        return requested;
+    if (detected !== "unknown")
+        return detected;
+    return fallback;
+}
+export async function resolvePackageManagerProfile(cwd, requested, fallback = "npm") {
+    const detected = await detectPackageManagerDetails(cwd);
+    return createPackageManagerProfile(requested, detected, fallback);
+}
+export function createPackageManagerProfile(requested, detected, fallback = "npm") {
+    const manager = resolvePackageManager(requested, detected.manager, fallback);
+    return {
+        manager,
+        command: manager,
+        source: requested === "auto" && detected.manager !== "unknown"
+            ? detected.source
+            : "fallback",
+        lockfile: detected.lockfile,
+        packageManagerField: detected.packageManagerField,
+        yarnFlavor: manager === "yarn" ? detected.yarnFlavor ?? inferYarnFlavor(undefined) : undefined,
+    };
+}
+export function buildInstallInvocation(profile, options = {}) {
+    const args = profile.manager === "bun"
+        ? ["install", ...(options.frozen ? ["--frozen-lockfile"] : [])]
+        : profile.manager === "pnpm"
+            ? ["install", ...(options.frozen ? ["--frozen-lockfile"] : [])]
+            : profile.manager === "yarn"
+                ? [
+                    "install",
+                    ...(options.frozen
+                        ? [
+                            profile.yarnFlavor === "berry"
+                                ? "--immutable"
+                                : "--frozen-lockfile",
+                        ]
+                        : []),
+                ]
+                : options.ci || options.frozen
+                    ? ["ci"]
+                    : ["install"];
+    return {
+        command: profile.command,
+        args,
+        display: [profile.command, ...args].join(" "),
+    };
+}
+export function buildAddInvocation(profile, packages, options = {}) {
+    const args = profile.manager === "bun"
+        ? [
+            "add",
+            ...(options.exact ? ["--exact"] : []),
+            ...(options.noSave ? ["--no-save"] : []),
+            ...packages,
+        ]
+        : profile.manager === "pnpm"
+            ? [
+                "add",
+                ...(options.exact ? ["--save-exact"] : []),
+                ...(options.noSave ? ["--no-save"] : []),
+                ...packages,
+            ]
+            : profile.manager === "yarn"
+                ? ["add", ...(options.exact ? ["--exact"] : []), ...packages]
+                : [
+                    "install",
+                    ...(options.noSave ? ["--no-save"] : []),
+                    ...(options.exact ? ["--save-exact"] : []),
+                    ...packages,
+                ];
+    return {
+        command: profile.command,
+        args,
+        display: [profile.command, ...args].join(" "),
+    };
+}
+export function buildTestCommand(profile) {
+    return `${profile.command} test`;
+}
+async function fileExists(filePath) {
     try {
-        await access(pnpmLock);
-        return "pnpm";
+        return await Bun.file(filePath).exists();
     }
     catch {
-        // noop
+        return false;
     }
+}
+async function readPackageManagerField(cwd) {
+    const packageJsonPath = path.join(cwd, "package.json");
     try {
-        await access(npmLock);
-        return "npm";
+        const manifest = (await Bun.file(packageJsonPath).json());
+        return typeof manifest.packageManager === "string"
+            ? manifest.packageManager
+            : null;
     }
     catch {
-        return "unknown";
+        return null;
+    }
+}
+function parsePackageManagerField(value) {
+    const trimmed = value.trim();
+    if (trimmed.length === 0)
+        return null;
+    const [name, version] = trimmed.split("@", 2);
+    if (name !== "bun" && name !== "npm" && name !== "pnpm" && name !== "yarn") {
+        return null;
     }
+    return {
+        manager: name,
+        yarnFlavor: name === "yarn" ? inferYarnFlavor(version) : undefined,
+    };
+}
+function inferYarnFlavor(version) {
+    if (!version)
+        return "unknown";
+    const match = version.match(/^(\d+)/);
+    if (!match)
+        return "unknown";
+    return Number(match[1]) >= 2 ? "berry" : "classic";
 }

package/dist/pm/install.d.ts

@@ -1 +1,3 @@
-export declare function installDependencies(cwd: string, packageManager: "auto" | "npm" | "pnpm", detected: "npm" | "pnpm" | "unknown"): Promise<void>;
+import type { DetectedPackageManager, SelectedPackageManager } from "../types/index.js";
+import { type PackageManagerDetection } from "./detect.js";
+export declare function installDependencies(cwd: string, packageManager: SelectedPackageManager, detected: DetectedPackageManager | PackageManagerDetection): Promise<void>;

package/dist/pm/install.js

@@ -1,21 +1,22 @@
-import { spawn } from "node:child_process";
+import { buildInstallInvocation, createPackageManagerProfile, } from "./detect.js";
 export async function installDependencies(cwd, packageManager, detected) {
-    const selected = packageManager === "auto" ? (detected === "unknown" ? "npm" : detected) : packageManager;
-    const command = selected;
-    const args = ["install"];
-    await new Promise((resolve, reject) => {
-        const child = spawn(command, args, {
+    const detection = typeof detected === "string"
+        ? { manager: detected, source: "fallback" }
+        : detected;
+    const invocation = buildInstallInvocation(createPackageManagerProfile(packageManager, detection));
+    try {
+        const proc = Bun.spawn([invocation.command, ...invocation.args], {
             cwd,
-            stdio: "inherit",
-            shell: process.platform === "win32",
+            stdin: "inherit",
+            stdout: "inherit",
+            stderr: "inherit",
         });
-        child.on("exit", (code) => {
-            if (code === 0) {
-                resolve();
-                return;
-            }
-            reject(new Error(`${command} ${args.join(" ")} failed with exit code ${code ?? "unknown"}`));
-        });
-        child.on("error", reject);
-    });
+        const code = await proc.exited;
+        if (code !== 0) {
+            throw new Error(`${invocation.display} failed with exit code ${code}`);
+        }
+    }
+    catch (err) {
+        throw err instanceof Error ? err : new Error(String(err));
+    }
 }