@rainy-updates/cli 0.5.6 → 0.5.7

package/dist/core/analysis/run-silenced.js

@@ -0,0 +1,14 @@
+import process from "node:process";
+export async function runSilenced(fn) {
+    const stdoutWrite = process.stdout.write.bind(process.stdout);
+    const stderrWrite = process.stderr.write.bind(process.stderr);
+    process.stdout.write = (() => true);
+    process.stderr.write = (() => true);
+    try {
+        return await fn();
+    }
+    finally {
+        process.stdout.write = stdoutWrite;
+        process.stderr.write = stderrWrite;
+    }
+}

package/dist/core/analysis-bundle.js

@@ -1,7 +1,7 @@
-import { fetchChangelog } from "../commands/changelog/fetcher.js";
-import { applyImpactScores } from "./impact.js";
-import { applyRiskAssessments } from "../risk/index.js";
 import { check } from "./check.js";
+import { toAuditOptions, toHealthOptions, toLicenseOptions, toResolveOptions, toUnusedOptions, } from "./analysis/options.js";
+import { buildReviewItems } from "./analysis/review-items.js";
+import { runSilenced } from "./analysis/run-silenced.js";
 export async function buildAnalysisBundle(options, config = {}) {
     const baseCheckOptions = {
         ...options,
@@ -31,211 +31,3 @@ export async function buildAnalysisBundle(options, config = {}) {
             .map((source) => source.source),
     };
 }
-async function buildReviewItems(updates, auditResult, resolveResult, healthResult, licenseResult, unusedResult, config) {
-    const advisoryPackages = new Set(auditResult.packages.map((pkg) => pkg.packageName));
-    const impactedUpdates = applyImpactScores(updates, {
-        advisoryPackages,
-        workspaceDependentCount: (name) => updates.filter((item) => item.name === name).length,
-    });
-    const healthByName = new Map(healthResult.metrics.map((metric) => [metric.name, metric]));
-    const advisoriesByName = new Map();
-    const conflictsByName = new Map();
-    const licenseByName = new Map(licenseResult.packages.map((pkg) => [pkg.name, pkg]));
-    const licenseViolationNames = new Set(licenseResult.violations.map((pkg) => pkg.name));
-    const unusedByName = new Map();
-    for (const advisory of auditResult.advisories) {
-        const list = advisoriesByName.get(advisory.packageName) ?? [];
-        list.push(advisory);
-        advisoriesByName.set(advisory.packageName, list);
-    }
-    for (const conflict of resolveResult.conflicts) {
-        const list = conflictsByName.get(conflict.requester) ?? [];
-        list.push(conflict);
-        conflictsByName.set(conflict.requester, list);
-        const peerList = conflictsByName.get(conflict.peer) ?? [];
-        peerList.push(conflict);
-        conflictsByName.set(conflict.peer, peerList);
-    }
-    for (const issue of [...unusedResult.unused, ...unusedResult.missing]) {
-        const list = unusedByName.get(issue.name) ?? [];
-        list.push(issue);
-        unusedByName.set(issue.name, list);
-    }
-    const enrichedUpdates = await maybeAttachReleaseNotes(impactedUpdates, Boolean(config.includeChangelog));
-    return applyRiskAssessments(enrichedUpdates.map((update) => enrichUpdate(update, advisoriesByName, conflictsByName, healthByName, licenseByName, licenseViolationNames, unusedByName)), {
-        knownPackageNames: new Set(updates.map((item) => item.name)),
-    }).map((item) => ({
-        ...item,
-        update: {
-            ...item.update,
-            policyAction: derivePolicyAction(item),
-            decisionState: deriveDecisionState(item),
-            selectedByDefault: deriveDecisionState(item) !== "blocked",
-            blockedReason: deriveDecisionState(item) === "blocked"
-                ? item.update.recommendedAction
-                : undefined,
-            monitorReason: item.update.healthStatus === "stale" ? "Package health should be monitored." : undefined,
-        },
-    }));
-}
-function enrichUpdate(update, advisoriesByName, conflictsByName, healthByName, licenseByName, licenseViolationNames, unusedByName) {
-    const advisories = advisoriesByName.get(update.name) ?? [];
-    const peerConflicts = conflictsByName.get(update.name) ?? [];
-    const health = healthByName.get(update.name);
-    const license = licenseByName.get(update.name);
-    const unusedIssues = unusedByName.get(update.name) ?? [];
-    return {
-        update: {
-            ...update,
-            advisoryCount: advisories.length,
-            peerConflictSeverity: peerConflicts.some((item) => item.severity === "error")
-                ? "error"
-                : peerConflicts.length > 0
-                    ? "warning"
-                    : "none",
-            licenseStatus: licenseViolationNames.has(update.name)
-                ? "denied"
-                : license
-                    ? "allowed"
-                    : "review",
-            healthStatus: health?.flags[0] ?? "healthy",
-        },
-        advisories,
-        health,
-        peerConflicts,
-        license,
-        unusedIssues,
-        selected: true,
-    };
-}
-function derivePolicyAction(item) {
-    if (item.update.peerConflictSeverity === "error" || item.update.licenseStatus === "denied") {
-        return "block";
-    }
-    if ((item.update.advisoryCount ?? 0) > 0 || item.update.riskLevel === "critical") {
-        return "review";
-    }
-    if (item.update.healthStatus === "stale" || item.update.healthStatus === "archived") {
-        return "monitor";
-    }
-    return "allow";
-}
-function deriveDecisionState(item) {
-    if (item.update.peerConflictSeverity === "error" || item.update.licenseStatus === "denied") {
-        return "blocked";
-    }
-    if ((item.update.advisoryCount ?? 0) > 0 || item.update.riskLevel === "critical") {
-        return "actionable";
-    }
-    if (item.update.riskLevel === "high" || item.update.diffType === "major") {
-        return "review";
-    }
-    return "safe";
-}
-async function maybeAttachReleaseNotes(updates, includeChangelog) {
-    if (!includeChangelog || updates.length === 0) {
-        return updates;
-    }
-    const enriched = await Promise.all(updates.map(async (update) => ({
-        ...update,
-        releaseNotesSummary: summarizeChangelog(await fetchChangelog(update.name, update.repository)),
-    })));
-    return enriched;
-}
-function summarizeChangelog(content) {
-    if (!content)
-        return undefined;
-    const lines = content
-        .split(/\r?\n/)
-        .map((line) => line.trim())
-        .filter(Boolean);
-    const title = lines.find((line) => line.startsWith("#"))?.replace(/^#+\s*/, "") ?? "Release notes";
-    const excerpt = lines.find((line) => !line.startsWith("#")) ?? "No summary available.";
-    return {
-        source: content.includes("# Release") ? "github-release" : "changelog-file",
-        title,
-        excerpt: excerpt.slice(0, 240),
-    };
-}
-async function runSilenced(fn) {
-    const stdoutWrite = process.stdout.write.bind(process.stdout);
-    const stderrWrite = process.stderr.write.bind(process.stderr);
-    process.stdout.write = (() => true);
-    process.stderr.write = (() => true);
-    try {
-        return await fn();
-    }
-    finally {
-        process.stdout.write = stdoutWrite;
-        process.stderr.write = stderrWrite;
-    }
-}
-function toAuditOptions(options) {
-    return {
-        cwd: options.cwd,
-        workspace: options.workspace,
-        severity: undefined,
-        fix: false,
-        dryRun: true,
-        commit: false,
-        packageManager: "auto",
-        reportFormat: "json",
-        sourceMode: "auto",
-        jsonFile: undefined,
-        concurrency: options.concurrency,
-        registryTimeoutMs: options.registryTimeoutMs,
-        silent: true,
-    };
-}
-function toResolveOptions(options) {
-    return {
-        cwd: options.cwd,
-        workspace: options.workspace,
-        afterUpdate: true,
-        safe: false,
-        jsonFile: undefined,
-        concurrency: options.concurrency,
-        registryTimeoutMs: options.registryTimeoutMs,
-        cacheTtlSeconds: options.cacheTtlSeconds,
-        silent: true,
-    };
-}
-function toHealthOptions(options) {
-    return {
-        cwd: options.cwd,
-        workspace: options.workspace,
-        staleDays: 365,
-        includeDeprecated: true,
-        includeAlternatives: false,
-        reportFormat: "json",
-        jsonFile: undefined,
-        concurrency: options.concurrency,
-        registryTimeoutMs: options.registryTimeoutMs,
-    };
-}
-function toLicenseOptions(options) {
-    return {
-        cwd: options.cwd,
-        workspace: options.workspace,
-        allow: undefined,
-        deny: undefined,
-        sbomFile: undefined,
-        jsonFile: undefined,
-        diffMode: false,
-        concurrency: options.concurrency,
-        registryTimeoutMs: options.registryTimeoutMs,
-        cacheTtlSeconds: options.cacheTtlSeconds,
-    };
-}
-function toUnusedOptions(options) {
-    return {
-        cwd: options.cwd,
-        workspace: options.workspace,
-        srcDirs: ["src", "."],
-        includeDevDependencies: true,
-        fix: false,
-        dryRun: true,
-        jsonFile: undefined,
-        concurrency: options.concurrency,
-    };
-}

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

package/dist/core/review-model.js

@@ -1,6 +1,9 @@
 import path from "node:path";
 import { createSummary, finalizeSummary } from "./summary.js";
 import { buildAnalysisBundle } from "./analysis-bundle.js";
+export { createDoctorResult } from "./doctor/result.js";
+export { renderDoctorAgentReport, renderDoctorResult, } from "./doctor/render.js";
+import { deriveReviewVerdict } from "./review-verdict.js";
 export async function buildReviewResult(options) {
     const includeChangelog = ("showChangelog" in options && options.showChangelog === true) ||
         ("includeChangelog" in options && options.includeChangelog === true) ||
@@ -48,17 +51,6 @@ export async function buildReviewResult(options) {
         ],
     };
 }
-export function createDoctorResult(review) {
-    const verdict = review.summary.verdict ?? deriveVerdict(review.items, review.errors);
-    const primaryFindings = buildPrimaryFindings(review);
-    return {
-        verdict,
-        summary: review.summary,
-        review,
-        primaryFindings,
-        recommendedCommand: recommendCommand(review, verdict),
-    };
-}
 export function renderReviewResult(review) {
     const lines = [];
     lines.push(`Project: ${review.projectPath}`);
@@ -119,17 +111,6 @@ export function renderReviewResult(review) {
     lines.push(`Summary: ${review.summary.updatesFound} updates, riskPackages=${review.summary.riskPackages ?? 0}, securityPackages=${review.summary.securityPackages ?? 0}, peerConflictPackages=${review.summary.peerConflictPackages ?? 0}`);
     return lines.join("\n");
 }
-export function renderDoctorResult(result, verdictOnly = false) {
-    const lines = [
-        `State: ${result.verdict}`,
-        `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}`);
-    }
-    return lines.join("\n");
-}
 function matchesReviewFilters(item, options) {
     if ("securityOnly" in options && options.securityOnly && item.advisories.length === 0) {
         return false;
@@ -196,51 +177,6 @@ function createReviewSummary(base, items, errors, warnings, interactiveSession,
     summary.monitorPackages = items.filter((item) => item.update.policyAction === "monitor").length;
     summary.decisionPackages = items.length;
     summary.degradedSources = degradedSources;
-    summary.verdict = deriveVerdict(items, errors);
+    summary.verdict = deriveReviewVerdict(items, errors);
     return summary;
 }
-function deriveVerdict(items, errors) {
-    if (items.some((item) => item.update.peerConflictSeverity === "error" ||
-        item.update.licenseStatus === "denied")) {
-        return "blocked";
-    }
-    if (items.some((item) => item.advisories.length > 0 || item.update.riskLevel === "critical")) {
-        return "actionable";
-    }
-    if (errors.length > 0 ||
-        items.some((item) => item.update.riskLevel === "high" || item.update.diffType === "major")) {
-        return "review";
-    }
-    return "safe";
-}
-function buildPrimaryFindings(review) {
-    const findings = [];
-    if ((review.summary.peerConflictPackages ?? 0) > 0) {
-        findings.push(`${review.summary.peerConflictPackages} package(s) have peer conflicts.`);
-    }
-    if ((review.summary.licenseViolationPackages ?? 0) > 0) {
-        findings.push(`${review.summary.licenseViolationPackages} package(s) violate license policy.`);
-    }
-    if ((review.summary.securityPackages ?? 0) > 0) {
-        findings.push(`${review.summary.securityPackages} package(s) have security advisories.`);
-    }
-    if ((review.summary.riskPackages ?? 0) > 0) {
-        findings.push(`${review.summary.riskPackages} package(s) are high risk.`);
-    }
-    if (review.errors.length > 0) {
-        findings.push(`${review.errors.length} execution error(s) need review before treating the result as clean.`);
-    }
-    if (findings.length === 0) {
-        findings.push("No blocking findings; remaining updates are low-risk.");
-    }
-    return findings;
-}
-function recommendCommand(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";
-}

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

@@ -0,0 +1,2 @@
+import type { ReviewItem, Verdict } from "../types/index.js";
+export declare function deriveReviewVerdict(items: ReviewItem[], errors: string[]): Verdict;