@rainy-updates/cli 0.5.4 → 0.5.7

package/dist/core/doctor/findings.d.ts

@@ -0,0 +1,2 @@
+import type { DoctorFinding, ReviewResult } from "../../types/index.js";
+export declare function buildDoctorFindings(review: ReviewResult): DoctorFinding[];

package/dist/core/doctor/findings.js

@@ -0,0 +1,166 @@
+import path from "node:path";
+export function buildDoctorFindings(review) {
+    const findings = [];
+    for (const error of review.errors) {
+        findings.push({
+            id: `execution-error:${error}`,
+            code: "execution-error",
+            category: "Registry / Execution",
+            severity: "error",
+            scope: "project",
+            summary: error,
+            details: "Execution errors make the scan incomplete or require operator review.",
+            help: "Resolve execution and registry issues before treating the run as clean.",
+            recommendedAction: "Run `rup review --interactive` after fixing execution failures.",
+            evidence: [error],
+        });
+    }
+    for (const degradedSource of review.summary.degradedSources ?? []) {
+        findings.push({
+            id: `degraded-source:${degradedSource}`,
+            code: "degraded-advisory-source",
+            category: "Registry / Execution",
+            severity: "warning",
+            scope: "project",
+            summary: `${degradedSource} returned degraded advisory coverage.`,
+            details: "Security findings may be partial while an advisory source is degraded.",
+            help: "Retry the scan or pin the advisory source when full coverage matters.",
+            recommendedAction: "Re-run `rup doctor` or `rup audit --source` once the degraded source recovers.",
+            evidence: [degradedSource],
+        });
+    }
+    for (const item of review.items) {
+        const workspace = path.basename(item.update.packagePath);
+        if (item.update.peerConflictSeverity === "error" || item.update.peerConflictSeverity === "warning") {
+            findings.push({
+                id: `peer-conflict:${item.update.name}:${workspace}`,
+                code: "peer-conflict",
+                category: "Compatibility",
+                severity: item.update.peerConflictSeverity === "error" ? "error" : "warning",
+                scope: "package",
+                packageName: item.update.name,
+                workspace,
+                summary: `${item.update.name} has ${item.update.peerConflictSeverity} peer conflicts after the proposed upgrade.`,
+                details: item.peerConflicts[0]?.suggestion,
+                help: "Inspect peer dependency requirements before applying the update.",
+                recommendedAction: item.update.recommendedAction ?? "Review peer requirements in `rup review --interactive`.",
+                evidence: item.peerConflicts.map((conflict) => `${conflict.requester} -> ${conflict.peer}@${conflict.requiredRange}`),
+            });
+        }
+        if (item.update.licenseStatus === "denied") {
+            findings.push({
+                id: `license-denied:${item.update.name}:${workspace}`,
+                code: "license-policy-denied",
+                category: "Licensing",
+                severity: "error",
+                scope: "package",
+                packageName: item.update.name,
+                workspace,
+                summary: `${item.update.name} violates the current license policy.`,
+                details: item.license?.license,
+                help: "Keep denied licenses out of the approved update set.",
+                recommendedAction: item.update.recommendedAction ?? "Block this package in `rup review --interactive`.",
+            });
+        }
+        if ((item.update.advisoryCount ?? 0) > 0) {
+            findings.push({
+                id: `security-advisory:${item.update.name}:${workspace}`,
+                code: "security-advisory",
+                category: "Security",
+                severity: item.update.riskLevel === "critical" ? "error" : "warning",
+                scope: "package",
+                packageName: item.update.name,
+                workspace,
+                summary: `${item.update.name} has ${item.update.advisoryCount} known security advisories.`,
+                details: item.advisories[0]?.title,
+                help: "Prioritize secure minimum upgrades before applying other dependency changes.",
+                recommendedAction: item.update.recommendedAction ??
+                    "Run `rup review --security-only` and consider `rup audit --fix` for minimum safe patches.",
+                evidence: item.advisories.map((advisory) => advisory.cveId),
+            });
+        }
+        if (item.update.riskLevel === "critical" || item.update.riskLevel === "high") {
+            findings.push({
+                id: `release-risk:${item.update.name}:${workspace}`,
+                code: item.update.riskLevel === "critical" ? "release-risk-critical" : "release-risk-high",
+                category: "Release Risk",
+                severity: item.update.riskLevel === "critical" ? "error" : "warning",
+                scope: "package",
+                packageName: item.update.name,
+                workspace,
+                summary: `${item.update.name} is classified as ${item.update.riskLevel} release risk.`,
+                details: item.update.riskReasons?.[0],
+                help: "Use review mode to inspect why the update was classified as risky before applying it.",
+                recommendedAction: item.update.recommendedAction ?? "Keep this package in review until risk reasons are cleared.",
+                evidence: item.update.riskReasons,
+            });
+        }
+        if (item.update.diffType === "major") {
+            findings.push({
+                id: `major-upgrade:${item.update.name}:${workspace}`,
+                code: "major-upgrade",
+                category: "Release Risk",
+                severity: "warning",
+                scope: "package",
+                packageName: item.update.name,
+                workspace,
+                summary: `${item.update.name} is a major version upgrade.`,
+                help: "Major upgrades should be reviewed explicitly before being applied.",
+                recommendedAction: item.update.recommendedAction ?? "Review major changes in `rup review --interactive`.",
+            });
+        }
+        if (item.update.healthStatus === "stale" || item.update.healthStatus === "archived") {
+            findings.push({
+                id: `health:${item.update.name}:${workspace}`,
+                code: item.update.healthStatus === "archived" ? "package-archived" : "package-stale",
+                category: "Operational Health",
+                severity: "warning",
+                scope: "package",
+                packageName: item.update.name,
+                workspace,
+                summary: `${item.update.name} is flagged as ${item.update.healthStatus}.`,
+                help: "Monitor package health and plan alternatives if maintenance does not improve.",
+                recommendedAction: item.update.monitorReason ?? "Keep this package under monitoring in `rup review`.",
+            });
+        }
+        if (item.unusedIssues.length > 0) {
+            findings.push({
+                id: `unused:${item.update.name}:${workspace}`,
+                code: "unused-dependency-signal",
+                category: "Unused / Cleanup",
+                severity: "warning",
+                scope: "package",
+                packageName: item.update.name,
+                workspace,
+                summary: `${item.update.name} has unused or missing dependency signals.`,
+                details: item.unusedIssues[0]?.kind,
+                help: "Clean up unused or missing dependencies before widening the upgrade scope.",
+                recommendedAction: "Run `rup unused` to inspect cleanup opportunities.",
+            });
+        }
+    }
+    return findings.sort(compareDoctorFindings);
+}
+function compareDoctorFindings(left, right) {
+    const severityOrder = { error: 0, warning: 1 };
+    const categoryOrder = {
+        Security: 0,
+        Compatibility: 1,
+        Policy: 2,
+        Licensing: 3,
+        "Release Risk": 4,
+        "Operational Health": 5,
+        "Unused / Cleanup": 6,
+        "Workspace Integrity": 7,
+        "Registry / Execution": 8,
+    };
+    const bySeverity = severityOrder[left.severity] - severityOrder[right.severity];
+    if (bySeverity !== 0)
+        return bySeverity;
+    const byCategory = categoryOrder[left.category] - categoryOrder[right.category];
+    if (byCategory !== 0)
+        return byCategory;
+    const leftTarget = `${left.packageName ?? ""}:${left.workspace ?? ""}:${left.code}`;
+    const rightTarget = `${right.packageName ?? ""}:${right.workspace ?? ""}:${right.code}`;
+    return leftTarget.localeCompare(rightTarget);
+}

package/dist/core/doctor/render.d.ts

@@ -0,0 +1,3 @@
+import type { DoctorResult } from "../../types/index.js";
+export declare function renderDoctorResult(result: DoctorResult, verdictOnly?: boolean): string;
+export declare function renderDoctorAgentReport(result: DoctorResult): string;

package/dist/core/doctor/render.js

@@ -0,0 +1,44 @@
+export function renderDoctorResult(result, verdictOnly = false) {
+    const lines = [
+        `State: ${result.verdict}`,
+        `Score: ${result.score}/100 (${result.scoreLabel})`,
+        `PrimaryRisk: ${result.primaryFindings[0] ?? "No blocking findings."}`,
+        `NextAction: ${result.recommendedCommand}`,
+    ];
+    if (!verdictOnly) {
+        lines.push(`Counts: updates=${result.summary.updatesFound}, security=${result.summary.securityPackages ?? 0}, risk=${result.summary.riskPackages ?? 0}, peer=${result.summary.peerConflictPackages ?? 0}, license=${result.summary.licenseViolationPackages ?? 0}`);
+        lines.push(`NextActionReason: ${result.nextActionReason}`);
+    }
+    return lines.join("\n");
+}
+export function renderDoctorAgentReport(result) {
+    const lines = [
+        `Rainy Updates doctor report for ${result.review.projectPath}`,
+        `State: ${result.verdict}`,
+        `Score: ${result.score}/100 (${result.scoreLabel})`,
+        `PrimaryRisk: ${result.primaryFindings[0] ?? "No blocking findings."}`,
+        `NextAction: ${result.recommendedCommand}`,
+        `Why: ${result.nextActionReason}`,
+        "",
+        "Priority findings:",
+    ];
+    const findings = result.findings.slice(0, 8);
+    if (findings.length === 0) {
+        lines.push("- No blocking findings detected.");
+    }
+    else {
+        for (const finding of findings) {
+            const target = finding.packageName ? ` package=${finding.packageName}` : "";
+            lines.push(`- [${finding.severity}] ${finding.category}${target}: ${finding.summary}`);
+            if (finding.recommendedAction) {
+                lines.push(`  fix: ${finding.recommendedAction}`);
+            }
+            if (finding.help) {
+                lines.push(`  help: ${finding.help}`);
+            }
+        }
+    }
+    lines.push("");
+    lines.push(`Verification: ${result.recommendedCommand}`);
+    return lines.join("\n");
+}

package/dist/core/doctor/result.d.ts

@@ -0,0 +1,2 @@
+import type { DoctorResult, ReviewResult } from "../../types/index.js";
+export declare function createDoctorResult(review: ReviewResult): DoctorResult;

package/dist/core/doctor/result.js

@@ -0,0 +1,55 @@
+import { deriveReviewVerdict } from "../review-verdict.js";
+import { buildDoctorFindings } from "./findings.js";
+import { calculateDoctorScore, countFindingsByCategory, countFindingsBySeverity, labelDoctorScore, } from "./score.js";
+export function createDoctorResult(review) {
+    const verdict = review.summary.verdict ?? deriveReviewVerdict(review.items, review.errors);
+    const findings = buildDoctorFindings(review);
+    const score = calculateDoctorScore(findings);
+    const scoreLabel = labelDoctorScore(score);
+    const primaryFindings = findings.length > 0
+        ? findings.map((finding) => finding.summary)
+        : ["No blocking findings; remaining updates are low-risk."];
+    const recommendedCommand = recommendDoctorCommand(review, verdict);
+    const nextActionReason = describeNextActionReason(review, verdict);
+    review.summary.dependencyHealthScore = score;
+    review.summary.findingCountsByCategory = countFindingsByCategory(findings);
+    review.summary.findingCountsBySeverity = countFindingsBySeverity(findings);
+    review.summary.primaryFindingCode = findings[0]?.code;
+    review.summary.primaryFindingCategory = findings[0]?.category;
+    review.summary.nextActionReason = nextActionReason;
+    return {
+        verdict,
+        score,
+        scoreLabel,
+        summary: review.summary,
+        review,
+        findings,
+        primaryFindings,
+        recommendedCommand,
+        nextActionReason,
+    };
+}
+function recommendDoctorCommand(review, verdict) {
+    if (verdict === "blocked")
+        return "rup review --interactive";
+    if ((review.summary.securityPackages ?? 0) > 0)
+        return "rup review --security-only";
+    if (review.errors.length > 0 || review.items.length > 0)
+        return "rup review --interactive";
+    return "rup check";
+}
+function describeNextActionReason(review, verdict) {
+    if (verdict === "blocked") {
+        return "Blocked findings exist, so the update set needs an explicit package-by-package review before any mutation.";
+    }
+    if ((review.summary.securityPackages ?? 0) > 0) {
+        return "Security advisories are present, so the next step should focus on the secure subset first.";
+    }
+    if (review.errors.length > 0) {
+        return "Execution issues reduce trust in the current scan, so the result should be reviewed before treating it as clean.";
+    }
+    if (review.items.length > 0) {
+        return "Reviewable updates were found, so the next step is to inspect and approve the package set.";
+    }
+    return "No reviewable changes remain, so a normal check is enough to verify the repository stays clean.";
+}

package/dist/core/doctor/score.d.ts

@@ -0,0 +1,5 @@
+import type { DoctorFinding, DoctorFindingCategory, DoctorFindingSeverity, DoctorScoreLabel } from "../../types/index.js";
+export declare function calculateDoctorScore(findings: DoctorFinding[]): number;
+export declare function labelDoctorScore(score: number): DoctorScoreLabel;
+export declare function countFindingsByCategory(findings: DoctorFinding[]): Partial<Record<DoctorFindingCategory, number>>;
+export declare function countFindingsBySeverity(findings: DoctorFinding[]): Partial<Record<DoctorFindingSeverity, number>>;

package/dist/core/doctor/score.js

@@ -0,0 +1,28 @@
+export function calculateDoctorScore(findings) {
+    const uniqueErrorCodes = new Set(findings.filter((finding) => finding.severity === "error").map((finding) => finding.code));
+    const uniqueWarningCodes = new Set(findings.filter((finding) => finding.severity === "warning").map((finding) => finding.code));
+    return Math.max(0, 100 - uniqueErrorCodes.size * 12 - uniqueWarningCodes.size * 5);
+}
+export function labelDoctorScore(score) {
+    if (score >= 85)
+        return "Strong";
+    if (score >= 65)
+        return "Needs Review";
+    if (score >= 40)
+        return "Action Needed";
+    return "Blocked / Critical";
+}
+export function countFindingsByCategory(findings) {
+    const counts = {};
+    for (const finding of findings) {
+        counts[finding.category] = (counts[finding.category] ?? 0) + 1;
+    }
+    return counts;
+}
+export function countFindingsBySeverity(findings) {
+    const counts = {};
+    for (const finding of findings) {
+        counts[finding.severity] = (counts[finding.severity] ?? 0) + 1;
+    }
+    return counts;
+}

package/dist/core/options.d.ts

@@ -1,4 +1,4 @@
-import type { BaselineOptions, CheckOptions, UpgradeOptions, AuditOptions, BisectOptions, HealthOptions, UnusedOptions, ResolveOptions, LicenseOptions, SnapshotOptions, ReviewOptions, DoctorOptions, RiskLevel } from "../types/index.js";
+import type { BaselineOptions, CheckOptions, UpgradeOptions, AuditOptions, BisectOptions, HealthOptions, UnusedOptions, ResolveOptions, LicenseOptions, SnapshotOptions, ReviewOptions, DoctorOptions, RiskLevel, DashboardOptions, GaOptions } from "../types/index.js";
 import type { InitCiMode, InitCiSchedule } from "./init-ci.js";
 export type ParsedCliArgs = {
     command: "check";
@@ -52,6 +52,12 @@ export type ParsedCliArgs = {
 } | {
     command: "doctor";
     options: DoctorOptions;
+} | {
+    command: "dashboard";
+    options: DashboardOptions;
+} | {
+    command: "ga";
+    options: GaOptions;
 };
 export declare function parseCliArgs(argv: string[]): Promise<ParsedCliArgs>;
 export declare function ensureRiskLevel(value: string): RiskLevel;

package/dist/core/options.js

@@ -23,6 +23,8 @@ const KNOWN_COMMANDS = [
     "snapshot",
     "review",
     "doctor",
+    "dashboard",
+    "ga",
 ];
 export async function parseCliArgs(argv) {
     const firstArg = argv[0];
@@ -72,6 +74,14 @@ export async function parseCliArgs(argv) {
         const { parseDoctorArgs } = await import("../commands/doctor/parser.js");
         return { command, options: parseDoctorArgs(args) };
     }
+    if (command === "dashboard") {
+        const { parseDashboardArgs } = await import("../commands/dashboard/parser.js");
+        return { command, options: parseDashboardArgs(args) };
+    }
+    if (command === "ga") {
+        const { parseGaArgs } = await import("../commands/ga/parser.js");
+        return { command, options: parseGaArgs(args) };
+    }
     const base = {
         cwd: process.cwd(),
         target: "latest",
@@ -450,6 +460,10 @@ export async function parseCliArgs(argv) {
             base.showImpact = true;
             continue;
         }
+        if (current === "--show-links") {
+            base.showHomepage = true;
+            continue;
+        }
         if (current === "--show-homepage") {
             base.showHomepage = true;
             continue;

package/dist/core/review-model.d.ts

@@ -1,5 +1,5 @@
-import type { CheckOptions, DoctorOptions, DoctorResult, ReviewOptions, ReviewResult } from "../types/index.js";
+import type { CheckOptions, DoctorOptions, ReviewOptions, ReviewResult } from "../types/index.js";
+export { createDoctorResult } from "./doctor/result.js";
+export { renderDoctorAgentReport, renderDoctorResult, } from "./doctor/render.js";
 export declare function buildReviewResult(options: ReviewOptions | DoctorOptions | CheckOptions): Promise<ReviewResult>;
-export declare function createDoctorResult(review: ReviewResult): DoctorResult;
 export declare function renderReviewResult(review: ReviewResult): string;
-export declare function renderDoctorResult(result: DoctorResult, verdictOnly?: boolean): string;