@rainy-updates/cli 0.5.7 → 0.6.1

package/dist/commands/dashboard/runner.js

@@ -1,47 +1,77 @@
-import React from "react";
-import { render } from "ink";
-import { loadConfig } from "../../config/loader.js";
-import { DashboardTUI } from "../../ui/dashboard/DashboardTUI.js";
-// We'll need to load initial state or data before or during the render
-import { check } from "../../core/check.js";
-export async function runDashboard(options) {
-    // Load configuration
-    const resolvedConfig = await loadConfig(options.cwd);
-    // Create an initial check result. In a real scenario, this could run
-    // progressively in the TUI, but for simplicity we fetch initial data first.
-    const checkResult = await check({
+import { createDecisionPlan, defaultDecisionPlanPath, filterReviewItemsByFocus, writeDecisionPlan, } from "../../core/decision-plan.js";
+import { buildReviewResult, renderReviewResult } from "../../core/review-model.js";
+import { applySelectedUpdates } from "../../core/upgrade.js";
+import { runVerification } from "../../core/verification.js";
+import { runTui } from "../../ui/tui.js";
+import { writeStderr, writeStdout } from "../../utils/runtime.js";
+export async function runDashboard(options, prebuiltReview) {
+    const review = prebuiltReview ?? (await buildReviewResult({
         ...options,
-        // We do not want `check` to exit or log heavily here, the UI will take over.
-        logLevel: "error",
-    });
-    // Render the interactive Ink Dashboard
-    const { waitUntilExit } = render(React.createElement(DashboardTUI, {
-        options,
-        initialResult: checkResult,
+        interactive: false,
     }));
-    await waitUntilExit();
-    const finalStore = await import("../../ui/dashboard/store.js");
-    const finalState = finalStore.getStore()?.getState();
-    if (finalState?.shouldApply) {
-        process.stderr.write("[dashboard] Applying updates...\n");
-        const { applySelectedUpdates } = await import("../../core/upgrade.js");
-        const { detectPackageManager } = await import("../../pm/detect.js");
-        const { installDependencies } = await import("../../pm/install.js");
+    const visibleItems = filterReviewItemsByFocus(review.items, options.focus);
+    const selectedItems = await selectDashboardItems(options, visibleItems);
+    const decisionPlan = createDecisionPlan({
+        review,
+        selectedItems,
+        sourceCommand: "dashboard",
+        mode: options.mode,
+        focus: options.focus,
+    });
+    const decisionPlanFile = options.decisionPlanFile ?? defaultDecisionPlanPath(options.cwd);
+    await writeDecisionPlan(decisionPlanFile, decisionPlan);
+    review.decisionPlan = decisionPlan;
+    review.summary.decisionPlan = decisionPlanFile;
+    review.summary.interactiveSurface = "dashboard";
+    review.summary.queueFocus = options.focus;
+    review.summary.suggestedCommand =
+        options.mode === "upgrade" || options.applySelected
+            ? `rup upgrade --from-plan ${decisionPlanFile}`
+            : `rup upgrade --from-plan ${decisionPlanFile}`;
+    if ((options.mode === "upgrade" || options.applySelected) && selectedItems.length > 0) {
         await applySelectedUpdates({
             ...options,
-            install: false, // We handle installation explicitly below
+            install: false,
             packageManager: "auto",
-            sync: true,
-            lockfileMode: options.lockfileMode || "preserve",
-        }, finalState.updates);
-        // Install using the correct package manager if desired
-        const detected = await detectPackageManager(options.cwd);
-        await installDependencies(options.cwd, "auto", detected);
-        process.stderr.write("[dashboard] Successfully applied updates and installed dependencies.\n");
+            sync: options.workspace,
+        }, selectedItems.map((item) => item.update));
+        if (options.verify !== "none") {
+            const verification = await runVerification({
+                cwd: options.cwd,
+                verify: options.verify,
+                testCommand: options.testCommand,
+                verificationReportFile: options.verificationReportFile,
+                packageManager: "auto",
+            });
+            if (!verification.passed) {
+                review.errors.push(...verification.checks
+                    .filter((check) => !check.passed)
+                    .map((check) => `Verification failed for ${check.name}: ${check.error ?? check.command}`));
+            }
+        }
     }
+    writeStdout(renderReviewResult({
+        ...review,
+        items: selectedItems,
+        updates: selectedItems.map((item) => item.update),
+    }) + "\n");
+    writeStderr(`[dashboard] decision plan written to ${decisionPlanFile}\n`);
     return {
         completed: true,
-        errors: [],
-        warnings: [],
+        errors: review.errors,
+        warnings: review.warnings,
+        selectedUpdates: selectedItems.length,
+        decisionPlanFile,
     };
 }
+async function selectDashboardItems(options, visibleItems) {
+    if (visibleItems.length === 0) {
+        return [];
+    }
+    return runTui(visibleItems, {
+        title: options.mode === "upgrade"
+            ? "Rainy Dashboard: Upgrade Queue"
+            : "Rainy Dashboard: Review Queue",
+        subtitle: `focus=${options.focus}  mode=${options.mode}  Enter confirms the selected decision set`,
+    });
+}

package/dist/commands/doctor/parser.js

@@ -1,8 +1,8 @@
 import path from "node:path";
-import process from "node:process";
+import { exitProcess, getRuntimeCwd, writeStdout, } from "../../utils/runtime.js";
 export function parseDoctorArgs(args) {
     const options = {
-        cwd: process.cwd(),
+        cwd: getRuntimeCwd(),
         target: "latest",
         filter: undefined,
         reject: undefined,
@@ -36,11 +36,21 @@ export function parseDoctorArgs(args) {
         cooldownDays: undefined,
         prLimit: undefined,
         onlyChanged: false,
+        affected: false,
+        staged: false,
+        baseRef: undefined,
+        headRef: undefined,
+        sinceRef: undefined,
         ciProfile: "minimal",
         lockfileMode: "preserve",
         interactive: false,
         showImpact: true,
         showHomepage: true,
+        decisionPlanFile: undefined,
+        verify: "none",
+        testCommand: undefined,
+        verificationReportFile: undefined,
+        ciGate: "check",
         verdictOnly: false,
         includeChangelog: false,
         agentReport: false,
@@ -59,6 +69,39 @@ export function parseDoctorArgs(args) {
             options.workspace = true;
             continue;
         }
+        if (current === "--only-changed") {
+            options.onlyChanged = true;
+            continue;
+        }
+        if (current === "--affected") {
+            options.affected = true;
+            continue;
+        }
+        if (current === "--staged") {
+            options.staged = true;
+            continue;
+        }
+        if (current === "--base" && next) {
+            options.baseRef = next;
+            i += 1;
+            continue;
+        }
+        if (current === "--base")
+            throw new Error("Missing value for --base");
+        if (current === "--head" && next) {
+            options.headRef = next;
+            i += 1;
+            continue;
+        }
+        if (current === "--head")
+            throw new Error("Missing value for --head");
+        if (current === "--since" && next) {
+            options.sinceRef = next;
+            i += 1;
+            continue;
+        }
+        if (current === "--since")
+            throw new Error("Missing value for --since");
         if (current === "--verdict-only") {
             options.verdictOnly = true;
             continue;
@@ -79,8 +122,8 @@ export function parseDoctorArgs(args) {
         if (current === "--json-file")
             throw new Error("Missing value for --json-file");
         if (current === "--help" || current === "-h") {
-            process.stdout.write(DOCTOR_HELP);
-            process.exit(0);
+            writeStdout(DOCTOR_HELP);
+            exitProcess(0);
         }
         if (current.startsWith("-"))
             throw new Error(`Unknown doctor option: ${current}`);
@@ -99,6 +142,12 @@ Options:
   --include-changelog    Include release note summaries in the aggregated review data
   --agent-report         Print a prompt-ready remediation report for coding agents
   --workspace            Scan all workspace packages
+  --only-changed         Limit analysis to changed packages
+  --affected             Include changed packages and their dependents
+  --staged               Limit analysis 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
   --json-file <path>     Write JSON doctor report to file
   --cwd <path>
 `.trimStart();

package/dist/commands/doctor/runner.js

@@ -1,14 +1,14 @@
-import process from "node:process";
 import { buildReviewResult, createDoctorResult, renderDoctorAgentReport, renderDoctorResult, } from "../../core/review-model.js";
 import { stableStringify } from "../../utils/stable-json.js";
 import { writeFileAtomic } from "../../utils/io.js";
+import { writeStdout } from "../../utils/runtime.js";
 export async function runDoctor(options) {
     const review = await buildReviewResult(options);
     const doctor = createDoctorResult(review);
     const output = options.agentReport
         ? renderDoctorAgentReport(doctor)
         : renderDoctorResult(doctor, options.verdictOnly);
-    process.stdout.write(output + "\n");
+    writeStdout(output + "\n");
     if (options.jsonFile) {
         await writeFileAtomic(options.jsonFile, stableStringify(doctor, 2) + "\n");
     }

package/dist/commands/ga/parser.js

@@ -1,9 +1,14 @@
 import path from "node:path";
-import process from "node:process";
+import { exitProcess, getRuntimeCwd, writeStdout, } from "../../utils/runtime.js";
 export function parseGaArgs(args) {
     const options = {
-        cwd: process.cwd(),
+        cwd: getRuntimeCwd(),
         workspace: false,
+        affected: false,
+        staged: false,
+        baseRef: undefined,
+        headRef: undefined,
+        sinceRef: undefined,
         jsonFile: undefined,
     };
     for (let i = 0; i < args.length; i += 1) {
@@ -20,6 +25,35 @@ export function parseGaArgs(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 += 1;
+            continue;
+        }
+        if (current === "--base")
+            throw new Error("Missing value for --base");
+        if (current === "--head" && next) {
+            options.headRef = next;
+            i += 1;
+            continue;
+        }
+        if (current === "--head")
+            throw new Error("Missing value for --head");
+        if (current === "--since" && next) {
+            options.sinceRef = next;
+            i += 1;
+            continue;
+        }
+        if (current === "--since")
+            throw new Error("Missing value for --since");
         if (current === "--json-file" && next) {
             options.jsonFile = path.resolve(options.cwd, next);
             i += 1;
@@ -28,8 +62,8 @@ export function parseGaArgs(args) {
         if (current === "--json-file")
             throw new Error("Missing value for --json-file");
         if (current === "--help" || current === "-h") {
-            process.stdout.write(GA_HELP);
-            process.exit(0);
+            writeStdout(GA_HELP);
+            exitProcess(0);
         }
         if (current.startsWith("-"))
             throw new Error(`Unknown ga option: ${current}`);
@@ -45,6 +79,11 @@ Usage:
 
 Options:
   --workspace            Evaluate workspace package coverage
+  --affected             Evaluate changed workspace packages and dependents
+  --staged               Limit GA discovery 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
   --json-file <path>     Write JSON GA report to file
   --cwd <path>
 `.trimStart();

package/dist/commands/ga/runner.js

@@ -1,22 +1,24 @@
-import { promises as fs } from "node:fs";
 import path from "node:path";
-import process from "node:process";
 import { VersionCache } from "../../cache/cache.js";
-import { detectPackageManager } from "../../pm/detect.js";
+import { detectPackageManagerDetails } from "../../pm/detect.js";
 import { discoverPackageDirs } from "../../workspace/discover.js";
 import { stableStringify } from "../../utils/stable-json.js";
 import { writeFileAtomic } from "../../utils/io.js";
+import { writeStdout } from "../../utils/runtime.js";
 export async function runGa(options) {
-    const packageManager = await detectPackageManager(options.cwd);
-    const packageDirs = await discoverPackageDirs(options.cwd, options.workspace);
+    const packageManager = await detectPackageManagerDetails(options.cwd);
+    const packageDirs = await discoverPackageDirs(options.cwd, options.workspace, {
+        git: options,
+        includeDependents: options.affected === true,
+    });
     const cache = await VersionCache.create();
     const checks = [];
     checks.push({
         name: "package-manager",
-        status: packageManager === "unknown" ? "warn" : "pass",
-        detail: packageManager === "unknown"
-            ? "No supported lockfile was detected. npm-compatible execution is still possible."
-            : `Detected package manager: ${packageManager}.`,
+        status: packageManager.manager === "unknown" ? "warn" : "pass",
+        detail: packageManager.manager === "unknown"
+            ? "No supported lockfile was detected. Rainy can still run, but runtime/package verification will fall back to generic defaults."
+            : `Detected package manager: ${packageManager.manager} via ${packageManager.source}${packageManager.lockfile ? ` (${packageManager.lockfile})` : ""}${packageManager.packageManagerField ? ` [${packageManager.packageManagerField}]` : ""}. Runtime and verification can align with this package ecosystem, including Bun.`,
     });
     checks.push({
         name: "workspace-discovery",
@@ -40,6 +42,14 @@ export async function runGa(options) {
             ? "Built CLI entrypoint exists in dist/bin/cli.js."
             : "Built CLI entrypoint is missing; run the build before publishing a release artifact.",
     });
+    const compiledBinaryExists = await fileExists(path.resolve(options.cwd, "dist/rup"));
+    checks.push({
+        name: "runtime-artifacts",
+        status: compiledBinaryExists ? "pass" : "warn",
+        detail: compiledBinaryExists
+            ? "Compiled Bun runtime artifact exists in dist/rup."
+            : "Compiled Bun runtime artifact is missing; run bun run build:exe before publishing Bun-first release artifacts.",
+    });
     checks.push({
         name: "benchmark-gates",
         status: (await fileExists(path.resolve(options.cwd, "scripts/perf-smoke.mjs"))) &&
@@ -61,14 +71,14 @@ export async function runGa(options) {
     const result = {
         ready: errors.length === 0,
         projectPath: options.cwd,
-        packageManager,
+        packageManager: packageManager.manager,
         workspacePackages: packageDirs.length,
         cacheBackend: cache.backend,
         checks,
         warnings,
         errors,
     };
-    process.stdout.write(renderGaResult(result) + "\n");
+    writeStdout(renderGaResult(result) + "\n");
     if (options.jsonFile) {
         await writeFileAtomic(options.jsonFile, stableStringify(result, 2) + "\n");
     }
@@ -120,8 +130,7 @@ async function detectLockfile(cwd) {
 }
 async function fileExists(filePath) {
     try {
-        await fs.access(filePath);
-        return true;
+        return await Bun.file(filePath).exists();
     }
     catch {
         return false;

package/dist/commands/health/parser.js

@@ -1,9 +1,14 @@
 import path from "node:path";
-import process from "node:process";
+import { getRuntimeCwd } from "../../utils/runtime.js";
 export function parseHealthArgs(args) {
     const options = {
-        cwd: process.cwd(),
+        cwd: getRuntimeCwd(),
         workspace: false,
+        affected: false,
+        staged: false,
+        baseRef: undefined,
+        headRef: undefined,
+        sinceRef: undefined,
         staleDays: 365,
         includeDeprecated: true,
         includeAlternatives: false,
@@ -28,6 +33,37 @@ export function parseHealthArgs(args) {
             index += 1;
             continue;
         }
+        if (current === "--affected") {
+            options.affected = true;
+            index += 1;
+            continue;
+        }
+        if (current === "--staged") {
+            options.staged = true;
+            index += 1;
+            continue;
+        }
+        if (current === "--base" && next) {
+            options.baseRef = next;
+            index += 2;
+            continue;
+        }
+        if (current === "--base")
+            throw new Error("Missing value for --base");
+        if (current === "--head" && next) {
+            options.headRef = next;
+            index += 2;
+            continue;
+        }
+        if (current === "--head")
+            throw new Error("Missing value for --head");
+        if (current === "--since" && next) {
+            options.sinceRef = next;
+            index += 2;
+            continue;
+        }
+        if (current === "--since")
+            throw new Error("Missing value for --since");
         if (current === "--stale" && next) {
             // Accept "12m" → 365, "6m" → 180, "365d" → 365, or plain number
             const match = next.match(/^(\d+)(m|d)?$/);

package/dist/commands/health/runner.js

@@ -89,7 +89,11 @@ export async function runHealth(options) {
         errors: [],
         warnings: [],
     };
-    const packageDirs = await discoverPackageDirs(options.cwd, options.workspace);
+    const packageDirs = await discoverPackageDirs(options.cwd, options.workspace, {
+        git: options,
+        includeKinds: ["dependencies", "devDependencies", "optionalDependencies"],
+        includeDependents: options.affected === true,
+    });
     const versionMap = new Map();
     for (const dir of packageDirs) {
         let manifest;

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

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

package/dist/commands/hook/parser.js

@@ -0,0 +1,40 @@
+import path from "node:path";
+export function parseHookArgs(args) {
+    let cwd = process.cwd();
+    let action = "doctor";
+    for (let index = 0; index < args.length; index += 1) {
+        const current = args[index];
+        const next = args[index + 1];
+        if ((current === "install" || current === "uninstall" || current === "doctor") && index === 0) {
+            action = current;
+            continue;
+        }
+        if (current === "--cwd" && next) {
+            cwd = path.resolve(next);
+            index += 1;
+            continue;
+        }
+        if (current === "--cwd") {
+            throw new Error("Missing value for --cwd");
+        }
+        if (current === "--help" || current === "-h") {
+            process.stdout.write(HOOK_HELP);
+            process.exit(0);
+        }
+        if (current.startsWith("-")) {
+            throw new Error(`Unknown hook option: ${current}`);
+        }
+        throw new Error(`Unexpected hook argument: ${current}`);
+    }
+    return { cwd, action };
+}
+const HOOK_HELP = `
+rup hook — Install or inspect Rainy-managed git hooks
+
+Usage:
+  rup hook <install|uninstall|doctor> [options]
+
+Options:
+  --cwd <path>          Working directory (default: cwd)
+  --help                Show this help
+`.trimStart();

package/dist/commands/hook/runner.d.ts

@@ -0,0 +1,2 @@
+import type { HookOptions, HookResult } from "../../types/index.js";
+export declare function runHook(options: HookOptions): Promise<HookResult>;

package/dist/commands/hook/runner.js

@@ -0,0 +1,174 @@
+import { chmod, mkdir, unlink } from "node:fs/promises";
+import path from "node:path";
+import { writeStdout } from "../../utils/runtime.js";
+const MANAGED_MARKER = "# rainy-updates managed hook";
+const HOOKS = [
+    {
+        name: "pre-commit",
+        command: '$(resolve_rup) unused --workspace --staged && $(resolve_rup) resolve --workspace --staged',
+    },
+    {
+        name: "pre-push",
+        command: '$(resolve_rup) audit --workspace --affected --report summary',
+    },
+];
+export async function runHook(options) {
+    const hookDir = await resolveHookDir(options.cwd);
+    const result = {
+        action: options.action,
+        hookDir,
+        installed: [],
+        removed: [],
+        checked: [],
+        errors: [],
+        warnings: [],
+    };
+    if (options.action === "install") {
+        await mkdir(hookDir, { recursive: true });
+        for (const hook of HOOKS) {
+            const hookPath = path.join(hookDir, hook.name);
+            const existing = await readHookState(hookPath);
+            if (existing.status === "foreign") {
+                result.warnings.push(`Skipped ${hook.name}: existing hook is not Rainy-managed.`);
+                result.checked.push({ name: hook.name, status: "foreign" });
+                continue;
+            }
+            await Bun.write(hookPath, renderHookScript(hook.command));
+            await makeExecutable(hookPath);
+            result.installed.push(hook.name);
+            result.checked.push({ name: hook.name, status: "managed" });
+        }
+    }
+    else if (options.action === "uninstall") {
+        for (const hook of HOOKS) {
+            const hookPath = path.join(hookDir, hook.name);
+            const existing = await readHookState(hookPath);
+            if (existing.status === "managed") {
+                await unlink(hookPath).catch(() => undefined);
+                result.removed.push(hook.name);
+            }
+            else if (existing.status === "foreign") {
+                result.warnings.push(`Left ${hook.name} untouched: existing hook is not Rainy-managed.`);
+            }
+            result.checked.push({ name: hook.name, status: existing.status });
+        }
+    }
+    else {
+        for (const hook of HOOKS) {
+            const hookPath = path.join(hookDir, hook.name);
+            const existing = await readHookState(hookPath);
+            result.checked.push({ name: hook.name, status: existing.status });
+            if (existing.status === "foreign") {
+                result.warnings.push(`${hook.name} exists but is not Rainy-managed.`);
+            }
+        }
+    }
+    writeStdout(renderHookResult(result) + "\n");
+    return result;
+}
+async function resolveHookDir(cwd) {
+    const resolved = await runGit(cwd, ["rev-parse", "--git-path", "hooks"]);
+    if (!resolved.ok) {
+        throw new Error(`Unable to resolve git hooks directory: ${resolved.error}`);
+    }
+    const hookDir = resolved.stdout.trim();
+    if (hookDir.length === 0) {
+        throw new Error("Git hooks directory could not be determined.");
+    }
+    return path.resolve(cwd, hookDir);
+}
+async function readHookState(hookPath) {
+    try {
+        const file = Bun.file(hookPath);
+        if (!(await file.exists())) {
+            return { status: "missing" };
+        }
+        const content = await file.text();
+        return content.includes(MANAGED_MARKER)
+            ? { status: "managed", content }
+            : { status: "foreign", content };
+    }
+    catch {
+        return { status: "missing" };
+    }
+}
+function renderHookScript(command) {
+    return `#!/bin/sh
+${MANAGED_MARKER}
+set -eu
+
+resolve_rup() {
+  if command -v rup >/dev/null 2>&1; then
+    printf '%s' "rup"
+    return
+  fi
+  if command -v rainy-updates >/dev/null 2>&1; then
+    printf '%s' "rainy-updates"
+    return
+  fi
+  if command -v rainy-up >/dev/null 2>&1; then
+    printf '%s' "rainy-up"
+    return
+  fi
+  printf '%s\n' "Rainy Updates CLI not found in PATH." >&2
+  exit 127
+}
+
+${command}
+`;
+}
+async function makeExecutable(filePath) {
+    await chmod(filePath, 0o755);
+}
+async function runGit(cwd, args) {
+    try {
+        const proc = Bun.spawn(["git", ...args], {
+            cwd,
+            stdout: "pipe",
+            stderr: "pipe",
+        });
+        const [stdout, stderr, code] = await Promise.all([
+            new Response(proc.stdout).text(),
+            new Response(proc.stderr).text(),
+            proc.exited,
+        ]);
+        if (code !== 0) {
+            return { ok: false, error: stderr.trim() || `git ${args.join(" ")} failed` };
+        }
+        return { ok: true, stdout };
+    }
+    catch (error) {
+        return { ok: false, error: String(error) };
+    }
+}
+function renderHookResult(result) {
+    const lines = [
+        `Hook action: ${result.action}`,
+        `Hook dir: ${result.hookDir ?? "unknown"}`,
+    ];
+    if (result.installed.length > 0) {
+        lines.push(`Installed: ${result.installed.join(", ")}`);
+    }
+    if (result.removed.length > 0) {
+        lines.push(`Removed: ${result.removed.join(", ")}`);
+    }
+    if (result.checked.length > 0) {
+        lines.push("Checks:");
+        for (const check of result.checked) {
+            lines.push(`- ${check.name}: ${check.status}`);
+        }
+    }
+    if (result.warnings.length > 0) {
+        lines.push("Warnings:");
+        for (const warning of result.warnings) {
+            lines.push(`- ${warning}`);
+        }
+    }
+    if (result.errors.length > 0) {
+        lines.push("Errors:");
+        for (const error of result.errors) {
+            lines.push(`- ${error}`);
+        }
+    }
+    return lines.join("\n");
+}