@rainy-updates/cli 0.5.7 → 0.6.1

package/dist/core/options.js

@@ -1,6 +1,6 @@
 import path from "node:path";
-import process from "node:process";
 import { loadConfig } from "../config/loader.js";
+import { getRuntimeCwd } from "../utils/runtime.js";
 const DEFAULT_INCLUDE_KINDS = [
     "dependencies",
     "devDependencies",
@@ -25,6 +25,7 @@ const KNOWN_COMMANDS = [
     "doctor",
     "dashboard",
     "ga",
+    "hook",
 ];
 export async function parseCliArgs(argv) {
     const firstArg = argv[0];
@@ -82,8 +83,12 @@ export async function parseCliArgs(argv) {
         const { parseGaArgs } = await import("../commands/ga/parser.js");
         return { command, options: parseGaArgs(args) };
     }
+    if (command === "hook") {
+        const { parseHookArgs } = await import("../commands/hook/parser.js");
+        return { command, options: parseHookArgs(args) };
+    }
     const base = {
-        cwd: process.cwd(),
+        cwd: getRuntimeCwd(),
         target: "latest",
         filter: undefined,
         reject: undefined,
@@ -117,11 +122,21 @@ export async function parseCliArgs(argv) {
         cooldownDays: undefined,
         prLimit: undefined,
         onlyChanged: false,
+        affected: false,
+        staged: false,
+        baseRef: undefined,
+        headRef: undefined,
+        sinceRef: undefined,
         ciProfile: "minimal",
         lockfileMode: "preserve",
         interactive: false,
         showImpact: false,
         showHomepage: false,
+        decisionPlanFile: undefined,
+        verify: "none",
+        testCommand: undefined,
+        verificationReportFile: undefined,
+        ciGate: "check",
     };
     let force = false;
     let initCiMode = "enterprise";
@@ -452,6 +467,38 @@ export async function parseCliArgs(argv) {
             base.onlyChanged = true;
             continue;
         }
+        if (current === "--affected") {
+            base.affected = true;
+            continue;
+        }
+        if (current === "--staged") {
+            base.staged = true;
+            continue;
+        }
+        if (current === "--base" && next) {
+            base.baseRef = next;
+            index += 1;
+            continue;
+        }
+        if (current === "--base") {
+            throw new Error("Missing value for --base");
+        }
+        if (current === "--head" && next) {
+            base.headRef = next;
+            index += 1;
+            continue;
+        }
+        if (current === "--head") {
+            throw new Error("Missing value for --head");
+        }
+        if (current === "--since" && next) {
+            base.sinceRef = next;
+            index += 1;
+            continue;
+        }
+        if (current === "--since") {
+            throw new Error("Missing value for --since");
+        }
         if (current === "--interactive") {
             base.interactive = true;
             continue;
@@ -492,6 +539,54 @@ export async function parseCliArgs(argv) {
         if (current === "--file") {
             throw new Error("Missing value for --file");
         }
+        if (current === "--plan-file" && next) {
+            base.decisionPlanFile = path.resolve(base.cwd, next);
+            index += 1;
+            continue;
+        }
+        if (current === "--plan-file") {
+            throw new Error("Missing value for --plan-file");
+        }
+        if (current === "--from-plan" && next) {
+            base.decisionPlanFile = path.resolve(base.cwd, next);
+            index += 1;
+            continue;
+        }
+        if (current === "--from-plan") {
+            throw new Error("Missing value for --from-plan");
+        }
+        if (current === "--verify" && next) {
+            base.verify = ensureVerificationMode(next);
+            index += 1;
+            continue;
+        }
+        if (current === "--verify") {
+            throw new Error("Missing value for --verify");
+        }
+        if (current === "--test-command" && next) {
+            base.testCommand = next;
+            index += 1;
+            continue;
+        }
+        if (current === "--test-command") {
+            throw new Error("Missing value for --test-command");
+        }
+        if (current === "--verification-report-file" && next) {
+            base.verificationReportFile = path.resolve(base.cwd, next);
+            index += 1;
+            continue;
+        }
+        if (current === "--verification-report-file") {
+            throw new Error("Missing value for --verification-report-file");
+        }
+        if (current === "--gate" && next) {
+            base.ciGate = ensureCiGate(next);
+            index += 1;
+            continue;
+        }
+        if (current === "--gate") {
+            throw new Error("Missing value for --gate");
+        }
         if (current.startsWith("-")) {
             throw new Error(`Unknown option: ${current}`);
         }
@@ -526,6 +621,7 @@ export async function parseCliArgs(argv) {
             install: args.includes("--install") || resolvedConfig.install === true,
             packageManager: cliPm === "auto" ? (configPm ?? "auto") : cliPm,
             sync: args.includes("--sync") || resolvedConfig.sync === true,
+            fromPlanFile: base.decisionPlanFile,
         };
         return { command, options: upgradeOptions };
     }
@@ -672,6 +768,21 @@ function applyConfig(base, config) {
     if (typeof config.onlyChanged === "boolean") {
         base.onlyChanged = config.onlyChanged;
     }
+    if (typeof config.affected === "boolean") {
+        base.affected = config.affected;
+    }
+    if (typeof config.staged === "boolean") {
+        base.staged = config.staged;
+    }
+    if (typeof config.baseRef === "string" && config.baseRef.length > 0) {
+        base.baseRef = config.baseRef;
+    }
+    if (typeof config.headRef === "string" && config.headRef.length > 0) {
+        base.headRef = config.headRef;
+    }
+    if (typeof config.sinceRef === "string" && config.sinceRef.length > 0) {
+        base.sinceRef = config.sinceRef;
+    }
     if (typeof config.ciProfile === "string") {
         base.ciProfile = ensureCiProfile(config.ciProfile);
     }
@@ -687,16 +798,35 @@ function applyConfig(base, config) {
     if (typeof config.showHomepage === "boolean") {
         base.showHomepage = config.showHomepage;
     }
+    if (typeof config.decisionPlanFile === "string") {
+        base.decisionPlanFile = path.resolve(base.cwd, config.decisionPlanFile);
+    }
+    if (typeof config.verify === "string") {
+        base.verify = ensureVerificationMode(config.verify);
+    }
+    if (typeof config.testCommand === "string") {
+        base.testCommand = config.testCommand;
+    }
+    if (typeof config.verificationReportFile === "string") {
+        base.verificationReportFile = path.resolve(base.cwd, config.verificationReportFile);
+    }
+    if (typeof config.ciGate === "string") {
+        base.ciGate = ensureCiGate(config.ciGate);
+    }
 }
 function parsePackageManager(args) {
     const index = args.indexOf("--pm");
     if (index === -1)
         return "auto";
     const value = args[index + 1] ?? "auto";
-    if (value === "auto" || value === "npm" || value === "pnpm") {
+    if (value === "auto" ||
+        value === "bun" ||
+        value === "npm" ||
+        value === "pnpm" ||
+        value === "yarn") {
         return value;
     }
-    throw new Error("--pm must be auto, npm or pnpm");
+    throw new Error("--pm must be auto, bun, npm, pnpm or yarn");
 }
 function ensureTarget(value) {
     if (value === "patch" ||
@@ -800,3 +930,21 @@ export function ensureRiskLevel(value) {
     }
     throw new Error("--risk must be critical, high, medium or low");
 }
+function ensureVerificationMode(value) {
+    if (value === "none" ||
+        value === "install" ||
+        value === "test" ||
+        value === "install,test") {
+        return value;
+    }
+    throw new Error("--verify must be none, install, test or install,test");
+}
+function ensureCiGate(value) {
+    if (value === "check" ||
+        value === "doctor" ||
+        value === "review" ||
+        value === "upgrade") {
+        return value;
+    }
+    throw new Error("--gate must be check, doctor, review or upgrade");
+}

package/dist/core/review-model.js

@@ -109,6 +109,9 @@ export function renderReviewResult(review) {
     }
     lines.push("");
     lines.push(`Summary: ${review.summary.updatesFound} updates, riskPackages=${review.summary.riskPackages ?? 0}, securityPackages=${review.summary.securityPackages ?? 0}, peerConflictPackages=${review.summary.peerConflictPackages ?? 0}`);
+    if (review.summary.decisionPlan) {
+        lines.push(`DecisionPlan: ${review.summary.decisionPlan}`);
+    }
     return lines.join("\n");
 }
 function matchesReviewFilters(item, options) {

package/dist/core/summary.js

@@ -69,6 +69,12 @@ export function createSummary(input) {
         primaryFindingCode: undefined,
         primaryFindingCategory: undefined,
         nextActionReason: undefined,
+        suggestedCommand: undefined,
+        decisionPlan: undefined,
+        interactiveSurface: undefined,
+        queueFocus: undefined,
+        verificationState: "not-run",
+        verificationFailures: 0,
     };
 }
 export function finalizeSummary(summary) {

package/dist/core/upgrade.js

@@ -5,17 +5,25 @@ import { detectPackageManager } from "../pm/detect.js";
 import { applyRangeStyle, parseVersion, compareVersions } from "../utils/semver.js";
 import { buildWorkspaceGraph } from "../workspace/graph.js";
 import { captureLockfileSnapshot, changedLockfiles, validateLockfileMode } from "../utils/lockfile.js";
+import { createSummary, finalizeSummary } from "./summary.js";
+import { readDecisionPlan, selectedUpdatesFromPlan } from "./decision-plan.js";
+import { runVerification } from "./verification.js";
 export async function upgrade(options) {
     validateLockfileMode(options.lockfileMode, options.install);
     const lockfilesBefore = await captureLockfileSnapshot(options.cwd);
-    const checkResult = await check(options);
+    const checkResult = options.fromPlanFile
+        ? await createUpgradeResultFromPlan(options)
+        : await check(options);
     if (checkResult.updates.length === 0) {
         return {
             ...checkResult,
             changed: false,
         };
     }
-    await applySelectedUpdates(options, checkResult.updates);
+    const selectedUpdates = options.fromPlanFile
+        ? checkResult.updates
+        : checkResult.updates;
+    await applySelectedUpdates(options, selectedUpdates);
     const lockfileChanges = await changedLockfiles(options.cwd, lockfilesBefore);
     if (lockfileChanges.length > 0 && (options.lockfileMode === "preserve" || options.lockfileMode === "error")) {
         throw new Error(`Lockfile changes detected in ${options.lockfileMode} mode: ${lockfileChanges.join(", ")}`);
@@ -23,6 +31,18 @@ export async function upgrade(options) {
     if (lockfileChanges.length > 0 && options.lockfileMode === "update") {
         checkResult.warnings.push(`Lockfiles changed: ${lockfileChanges.map((item) => item.split("/").pop()).join(", ")}`);
     }
+    if (options.verify !== "none") {
+        const verification = await runVerification(options);
+        checkResult.summary.verificationState = verification.passed
+            ? "passed"
+            : "failed";
+        checkResult.summary.verificationFailures = verification.checks.filter((check) => !check.passed).length;
+        if (!verification.passed) {
+            checkResult.errors.push(...verification.checks
+                .filter((check) => !check.passed)
+                .map((check) => `Verification failed for ${check.name}: ${check.error ?? check.command}`));
+        }
+    }
     return {
         ...checkResult,
         changed: true,
@@ -59,6 +79,48 @@ export async function applySelectedUpdates(options, updates) {
         await installDependencies(options.cwd, options.packageManager, detected);
     }
 }
+async function createUpgradeResultFromPlan(options) {
+    if (!options.fromPlanFile) {
+        throw new Error("Missing decision plan file.");
+    }
+    const plan = await readDecisionPlan(options.fromPlanFile);
+    const packageManager = await detectPackageManager(options.cwd);
+    const updates = selectedUpdatesFromPlan(plan);
+    const packagePaths = Array.from(new Set(updates.map((update) => update.packagePath))).sort((left, right) => left.localeCompare(right));
+    const summary = finalizeSummary(createSummary({
+        scannedPackages: packagePaths.length,
+        totalDependencies: updates.length,
+        checkedDependencies: updates.length,
+        updatesFound: updates.length,
+        upgraded: 0,
+        skipped: 0,
+        warmedPackages: 0,
+        errors: [],
+        warnings: [],
+        durations: {
+            totalMs: 0,
+            discoveryMs: 0,
+            registryMs: 0,
+            cacheMs: 0,
+        },
+    }));
+    summary.decisionPlan = options.fromPlanFile;
+    summary.interactiveSurface = plan.interactiveSurface;
+    summary.queueFocus = plan.focus;
+    summary.updatesFound = updates.length;
+    return {
+        projectPath: options.cwd,
+        packagePaths,
+        packageManager,
+        target: plan.target,
+        timestamp: new Date().toISOString(),
+        summary,
+        updates,
+        errors: [],
+        warnings: [],
+        changed: false,
+    };
+}
 function applyWorkspaceSync(manifestsByPath, orderedPaths, localPackageNames, includeKinds, updates) {
     const desiredByPackage = new Map();
     for (const update of updates) {

package/dist/core/verification.d.ts

@@ -0,0 +1,2 @@
+import type { UpgradeOptions, VerificationResult } from "../types/index.js";
+export declare function runVerification(options: Pick<UpgradeOptions, "cwd" | "verify" | "testCommand" | "verificationReportFile" | "packageManager">): Promise<VerificationResult>;

package/dist/core/verification.js

@@ -0,0 +1,108 @@
+import { buildInstallInvocation, buildTestCommand, createPackageManagerProfile, detectPackageManagerDetails, } from "../pm/detect.js";
+import { installDependencies } from "../pm/install.js";
+import { stableStringify } from "../utils/stable-json.js";
+import { writeFileAtomic } from "../utils/io.js";
+import { readEnv } from "../utils/runtime.js";
+export async function runVerification(options) {
+    const mode = options.verify;
+    if (mode === "none") {
+        const result = {
+            mode,
+            passed: true,
+            checks: [],
+        };
+        await maybeWriteVerificationReport(options.verificationReportFile, result);
+        return result;
+    }
+    const checks = [];
+    const detected = await detectPackageManagerDetails(options.cwd);
+    const profile = createPackageManagerProfile(options.packageManager, detected, "bun");
+    if (includesInstall(mode)) {
+        const installInvocation = buildInstallInvocation(profile);
+        checks.push(await runCheck("install", installInvocation.display, async () => {
+            await installDependencies(options.cwd, options.packageManager, detected);
+        }));
+    }
+    if (includesTest(mode)) {
+        const command = options.testCommand ??
+            defaultTestCommand(profile);
+        checks.push(await runShellCheck(options.cwd, command));
+    }
+    const result = {
+        mode,
+        passed: checks.every((check) => check.passed),
+        checks,
+    };
+    await maybeWriteVerificationReport(options.verificationReportFile, result);
+    return result;
+}
+function includesInstall(mode) {
+    return mode === "install" || mode === "install,test";
+}
+function includesTest(mode) {
+    return mode === "test" || mode === "install,test";
+}
+function defaultTestCommand(profile) {
+    return buildTestCommand(profile);
+}
+async function runShellCheck(cwd, command) {
+    const startedAt = Date.now();
+    try {
+        const shell = readEnv("SHELL") || "sh";
+        const proc = Bun.spawn([shell, "-lc", command], {
+            cwd,
+            stdin: "inherit",
+            stdout: "inherit",
+            stderr: "inherit",
+        });
+        const exitCode = await proc.exited;
+        return {
+            name: "test",
+            command,
+            passed: exitCode === 0,
+            exitCode,
+            durationMs: Math.max(0, Date.now() - startedAt),
+            error: exitCode === 0
+                ? undefined
+                : `${command} failed with exit code ${exitCode}`,
+        };
+    }
+    catch (error) {
+        return {
+            name: "test",
+            command,
+            passed: false,
+            exitCode: 1,
+            durationMs: Math.max(0, Date.now() - startedAt),
+            error: String(error),
+        };
+    }
+}
+async function runCheck(name, command, action) {
+    const startedAt = Date.now();
+    try {
+        await action();
+        return {
+            name,
+            command,
+            passed: true,
+            exitCode: 0,
+            durationMs: Math.max(0, Date.now() - startedAt),
+        };
+    }
+    catch (error) {
+        return {
+            name,
+            command,
+            passed: false,
+            exitCode: 1,
+            durationMs: Math.max(0, Date.now() - startedAt),
+            error: String(error),
+        };
+    }
+}
+async function maybeWriteVerificationReport(filePath, result) {
+    if (!filePath)
+        return;
+    await writeFileAtomic(filePath, stableStringify(result, 2) + "\n");
+}

package/dist/core/warm-cache.js

@@ -1,4 +1,3 @@
-import process from "node:process";
 import { collectDependencies, readManifest } from "../parsers/package-json.js";
 import { matchesPattern } from "../utils/pattern.js";
 import { VersionCache } from "../cache/cache.js";
@@ -7,6 +6,7 @@ import { detectPackageManager } from "../pm/detect.js";
 import { discoverPackageDirs } from "../workspace/discover.js";
 import { createSummary, finalizeSummary } from "./summary.js";
 import { formatClassifiedMessage } from "./errors.js";
+import { writeStdout } from "../utils/runtime.js";
 export async function warmCache(options) {
     const startedAt = Date.now();
     let discoveryMs = 0;
@@ -14,7 +14,11 @@ export async function warmCache(options) {
     let registryMs = 0;
     const discoveryStartedAt = Date.now();
     const packageManager = await detectPackageManager(options.cwd);
-    const packageDirs = await discoverPackageDirs(options.cwd, options.workspace);
+    const packageDirs = await discoverPackageDirs(options.cwd, options.workspace, {
+        git: options,
+        includeKinds: options.includeKinds,
+        includeDependents: options.affected === true,
+    });
     discoveryMs += Date.now() - discoveryStartedAt;
     const cache = await VersionCache.create();
     const registryClient = new NpmRegistryClient(options.cwd, {
@@ -39,7 +43,7 @@ export async function warmCache(options) {
         if (!options.stream)
             return;
         streamedEvents += 1;
-        process.stdout.write(`${message}\n`);
+        writeStdout(`${message}\n`);
     };
     for (const packageDir of packageDirs) {
         try {

package/dist/generated/version.d.ts

@@ -0,0 +1 @@
+export declare const CLI_VERSION = "0.6.1";

package/dist/generated/version.js

@@ -0,0 +1,2 @@
+// This file is generated by scripts/sync-version.mjs.
+export const CLI_VERSION = "0.6.1";

package/dist/git/scope.d.ts

@@ -0,0 +1,19 @@
+import type { DependencyKind } from "../types/index.js";
+export interface GitScopeOptions {
+    onlyChanged?: boolean;
+    affected?: boolean;
+    staged?: boolean;
+    baseRef?: string;
+    headRef?: string;
+    sinceRef?: string;
+}
+export interface ScopedPackageDirsResult {
+    packageDirs: string[];
+    warnings: string[];
+    changedFiles: string[];
+}
+export declare function hasGitScope(options: GitScopeOptions): boolean;
+export declare function scopePackageDirsByGit(cwd: string, packageDirs: string[], options: GitScopeOptions, config?: {
+    includeKinds?: DependencyKind[];
+    includeDependents?: boolean;
+}): Promise<ScopedPackageDirsResult>;