@rainy-updates/cli 0.6.0 → 0.6.2

package/dist/commands/bisect/oracle.js

@@ -1,5 +1,6 @@
 import path from "node:path";
-import { detectPackageManager, resolvePackageManager } from "../../pm/detect.js";
+import { buildAddInvocation, createPackageManagerProfile, detectPackageManagerDetails, } from "../../pm/detect.js";
+import { buildShellInvocation } from "../../utils/shell.js";
 /**
  * The "oracle" for bisect: installs a specific version of a package
  * into the project's node_modules (via the shell), then runs --cmd.
@@ -11,9 +12,12 @@ export async function bisectOracle(packageName, version, options) {
         process.stderr.write(`[bisect:dry-run] Would test ${packageName}@${version}\n`);
         return "skip";
     }
-    const detected = await detectPackageManager(options.cwd);
-    const packageManager = resolvePackageManager("auto", detected, "bun");
-    const installResult = await runShell(buildInstallCommand(packageManager, packageName, version), options.cwd);
+    const detected = await detectPackageManagerDetails(options.cwd);
+    const profile = createPackageManagerProfile("auto", detected, "bun");
+    const installResult = await runCommand(buildAddInvocation(profile, [`${packageName}@${version}`], {
+        exact: true,
+        noSave: true,
+    }), options.cwd);
     if (installResult !== 0) {
         process.stderr.write(`[bisect] Failed to install ${packageName}@${version}, skipping.\n`);
         return "skip";
@@ -26,8 +30,8 @@ export async function bisectOracle(packageName, version, options) {
 }
 async function runShell(command, cwd) {
     try {
-        const shellCmd = process.env.SHELL || "sh";
-        const proc = Bun.spawn([shellCmd, "-c", command], {
+        const invocation = buildShellInvocation(command);
+        const proc = Bun.spawn([invocation.shell, ...invocation.args], {
             cwd: path.resolve(cwd),
             stdout: "pipe",
             stderr: "pipe",
@@ -38,16 +42,16 @@ async function runShell(command, cwd) {
         return 1;
     }
 }
-function buildInstallCommand(packageManager, packageName, version) {
-    const spec = `${packageName}@${version}`;
-    switch (packageManager) {
-        case "bun":
-            return `bun add --exact --no-save ${spec}`;
-        case "pnpm":
-            return `pnpm add --save-exact --no-save ${spec}`;
-        case "yarn":
-            return `npm install --no-save --save-exact ${spec}`;
-        default:
-            return `npm install --no-save --save-exact ${spec}`;
+async function runCommand(command, cwd) {
+    try {
+        const proc = Bun.spawn([command.command, ...command.args], {
+            cwd: path.resolve(cwd),
+            stdout: "pipe",
+            stderr: "pipe",
+        });
+        return await proc.exited;
+    }
+    catch {
+        return 1;
     }
 }

package/dist/commands/bisect/runner.js

@@ -1,15 +1,16 @@
-import { detectPackageManager, resolvePackageManager } from "../../pm/detect.js";
+import { buildTestCommand, createPackageManagerProfile, detectPackageManagerDetails, } from "../../pm/detect.js";
 import { fetchBisectVersions, bisectVersions } from "./engine.js";
 /**
  * Entry point for the `bisect` command. Lazy-loaded by cli.ts.
  * Fully isolated: does NOT import anything from core/options.ts.
  */
 export async function runBisect(options) {
-    const detected = await detectPackageManager(options.cwd);
+    const detected = await detectPackageManagerDetails(options.cwd);
+    const profile = createPackageManagerProfile("auto", detected, "bun");
     const runtimeOptions = {
         ...options,
         testCommand: options.testCommand ||
-            `${resolvePackageManager("auto", detected, "bun")} test`,
+            buildTestCommand(profile),
     };
     process.stderr.write(`\n[bisect] Fetching available versions for ${runtimeOptions.packageName}...\n`);
     const versions = await fetchBisectVersions(runtimeOptions);

package/dist/commands/dashboard/parser.js

@@ -40,6 +40,11 @@ export function parseDashboardArgs(args) {
         cooldownDays: undefined,
         prLimit: undefined,
         onlyChanged: false,
+        affected: false,
+        staged: false,
+        baseRef: undefined,
+        headRef: undefined,
+        sinceRef: undefined,
         ciProfile: "minimal",
         lockfileMode: "preserve",
         interactive: true,
@@ -148,6 +153,42 @@ export function parseDashboardArgs(args) {
             options.workspace = true;
             continue;
         }
+        if (arg === "--only-changed") {
+            options.onlyChanged = true;
+            continue;
+        }
+        if (arg === "--affected") {
+            options.affected = true;
+            continue;
+        }
+        if (arg === "--staged") {
+            options.staged = true;
+            continue;
+        }
+        if (arg === "--base" && nextArg) {
+            options.baseRef = nextArg;
+            i++;
+            continue;
+        }
+        if (arg === "--base") {
+            throw new Error("Missing value for --base");
+        }
+        if (arg === "--head" && nextArg) {
+            options.headRef = nextArg;
+            i++;
+            continue;
+        }
+        if (arg === "--head") {
+            throw new Error("Missing value for --head");
+        }
+        if (arg === "--since" && nextArg) {
+            options.sinceRef = nextArg;
+            i++;
+            continue;
+        }
+        if (arg === "--since") {
+            throw new Error("Missing value for --since");
+        }
         if (arg === "--cwd" && nextArg) {
             options.cwd = path.resolve(nextArg);
             i++;

package/dist/commands/dashboard/runner.js

@@ -3,6 +3,7 @@ import { buildReviewResult, renderReviewResult } from "../../core/review-model.j
 import { applySelectedUpdates } from "../../core/upgrade.js";
 import { runVerification } from "../../core/verification.js";
 import { runTui } from "../../ui/tui.js";
+import { deriveDashboardInitialFilter, deriveDashboardInitialTab, } from "../../ui/dashboard-state.js";
 import { writeStderr, writeStdout } from "../../utils/runtime.js";
 export async function runDashboard(options, prebuiltReview) {
     const review = prebuiltReview ?? (await buildReviewResult({
@@ -73,5 +74,7 @@ async function selectDashboardItems(options, visibleItems) {
             ? "Rainy Dashboard: Upgrade Queue"
             : "Rainy Dashboard: Review Queue",
         subtitle: `focus=${options.focus}  mode=${options.mode}  Enter confirms the selected decision set`,
+        initialFilter: deriveDashboardInitialFilter(options),
+        initialTab: deriveDashboardInitialTab(options),
     });
 }

package/dist/commands/doctor/parser.js

@@ -36,6 +36,11 @@ 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,
@@ -64,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;
@@ -104,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/ga/parser.js

@@ -4,6 +4,11 @@ export function parseGaArgs(args) {
     const options = {
         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;
@@ -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,21 +1,24 @@
 import path from "node:path";
 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"
+        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}. Runtime and verification can align with this package ecosystem, including Bun.`,
+            : `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",
@@ -39,14 +42,16 @@ 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"));
+    const compiledBinaryExists = await detectCompiledBinary(options.cwd);
     checks.push({
         name: "runtime-artifacts",
         status: compiledBinaryExists ? "pass" : "warn",
         detail: compiledBinaryExists
-            ? "Compiled Bun runtime artifact exists in dist/rup."
+            ? "Compiled Bun runtime artifact exists in dist/."
             : "Compiled Bun runtime artifact is missing; run bun run build:exe before publishing Bun-first release artifacts.",
     });
+    checks.push(await detectAutomationEntryPoints(options.cwd));
+    checks.push(await detectPlatformSupport(options.cwd));
     checks.push({
         name: "benchmark-gates",
         status: (await fileExists(path.resolve(options.cwd, "scripts/perf-smoke.mjs"))) &&
@@ -68,7 +73,7 @@ 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,
@@ -125,6 +130,65 @@ async function detectLockfile(cwd) {
         detail: "No supported lockfile was detected.",
     };
 }
+async function detectCompiledBinary(cwd) {
+    return ((await fileExists(path.resolve(cwd, "dist/rup"))) ||
+        (await fileExists(path.resolve(cwd, "dist/rup.exe"))));
+}
+async function detectAutomationEntryPoints(cwd) {
+    const packageJsonPath = path.resolve(cwd, "package.json");
+    let scripts = {};
+    try {
+        const manifest = (await Bun.file(packageJsonPath).json());
+        scripts = manifest.scripts ?? {};
+    }
+    catch {
+        scripts = {};
+    }
+    const hasMakefile = (await fileExists(path.resolve(cwd, "Makefile"))) ||
+        (await fileExists(path.resolve(cwd, "makefile")));
+    const requiredScripts = ["build", "check", "test:prod"];
+    const missingScripts = requiredScripts.filter((script) => !scripts[script]);
+    if (hasMakefile && missingScripts.length === 0) {
+        return {
+            name: "automation-entrypoints",
+            status: "pass",
+            detail: "Portable automation entrypoints are available via package scripts and Makefile targets.",
+        };
+    }
+    if (missingScripts.length === 0) {
+        return {
+            name: "automation-entrypoints",
+            status: "pass",
+            detail: "Portable package scripts are available for build, check, and test:prod.",
+        };
+    }
+    return {
+        name: "automation-entrypoints",
+        status: "warn",
+        detail: `Missing automation entrypoints: ${missingScripts.join(", ")}.`,
+    };
+}
+async function detectPlatformSupport(cwd) {
+    const packageJsonPath = path.resolve(cwd, "package.json");
+    let scripts = {};
+    try {
+        const manifest = (await Bun.file(packageJsonPath).json());
+        scripts = manifest.scripts ?? {};
+    }
+    catch {
+        scripts = {};
+    }
+    const suspectScripts = Object.entries(scripts)
+        .filter(([, command]) => /\brm\s+-rf\b|\btest\s+-x\b|\bchmod\b|\bcp\s+-R\b/.test(command))
+        .map(([name]) => name);
+    return {
+        name: "platform-support",
+        status: suspectScripts.length === 0 ? "pass" : "warn",
+        detail: suspectScripts.length === 0
+            ? "No obvious POSIX-only package scripts were detected for release-critical automation."
+            : `These scripts still look POSIX-specific and may need extra Windows work: ${suspectScripts.join(", ")}.`,
+    };
+}
 async function fileExists(filePath) {
     try {
         return await Bun.file(filePath).exists();

package/dist/commands/health/parser.js

@@ -4,6 +4,11 @@ export function parseHealthArgs(args) {
     const options = {
         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>;