@rainy-updates/cli 0.6.0 → 0.6.1

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/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",
@@ -68,7 +71,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,

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>;

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");
+}

package/dist/commands/licenses/parser.js

@@ -2,6 +2,11 @@ export function parseLicensesArgs(args) {
     const options = {
         cwd: process.cwd(),
         workspace: false,
+        affected: false,
+        staged: false,
+        baseRef: undefined,
+        headRef: undefined,
+        sinceRef: undefined,
         allow: undefined,
         deny: undefined,
         sbomFile: undefined,
@@ -25,6 +30,35 @@ export function parseLicensesArgs(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 === "--diff") {
             options.diffMode = true;
             continue;
@@ -105,6 +139,11 @@ Options:
   --json-file <path>     Write JSON report to file
   --diff                 Show only packages with a different license than last scan
   --workspace            Scan all workspace packages
+  --affected             Scan changed workspace packages and 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
   --timeout <ms>         Registry request timeout (default: 10000)
   --concurrency <n>      Parallel registry requests (default: 12)
   --cwd <path>           Working directory (default: cwd)

package/dist/commands/licenses/runner.js

@@ -20,7 +20,11 @@ export async function runLicenses(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 allDeps = new Map(); // name → resolved version
     for (const packageDir of packageDirs) {
         let manifest;

package/dist/commands/resolve/graph/builder.js

@@ -22,7 +22,11 @@ export async function buildPeerGraph(options,
  * to inject proposed upgrade versions before writing them to disk).
  */
 resolvedVersionOverrides) {
-    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 cache = await VersionCache.create();
     const registry = new NpmRegistryClient(options.cwd, {
         timeoutMs: options.registryTimeoutMs,

package/dist/commands/resolve/parser.js

@@ -2,6 +2,11 @@ export function parseResolveArgs(args) {
     const options = {
         cwd: process.cwd(),
         workspace: false,
+        affected: false,
+        staged: false,
+        baseRef: undefined,
+        headRef: undefined,
+        sinceRef: undefined,
         afterUpdate: false,
         safe: false,
         jsonFile: undefined,
@@ -23,6 +28,35 @@ export function parseResolveArgs(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 === "--after-update") {
             options.afterUpdate = true;
             continue;
@@ -77,6 +111,11 @@ Options:
   --after-update        Simulate conflicts after applying pending \`rup check\` updates
   --safe                Exit non-zero if any error-level conflicts exist
   --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
   --json-file <path>    Write JSON conflict report to file
   --timeout <ms>        Registry request timeout in ms (default: 10000)
   --concurrency <n>     Parallel registry requests (default: 12)

package/dist/commands/resolve/runner.js

@@ -95,6 +95,11 @@ async function fetchProposedVersions(options) {
             cooldownDays: undefined,
             prLimit: undefined,
             onlyChanged: false,
+            affected: options.affected,
+            staged: options.staged,
+            baseRef: options.baseRef,
+            headRef: options.headRef,
+            sinceRef: options.sinceRef,
             ciProfile: "minimal",
             lockfileMode: "preserve",
             interactive: false,