@mergesignal/shared 0.2.2 → 0.2.4

package/dist/deriveCardOperationalObservations.js

@@ -0,0 +1,180 @@
+import { sortRecommendationsForDisplay } from "./actionsStepSummary.js";
+import { mapContributionToCatalogPhrase, mapExplainReasonToCatalogPhrase, mapFindingToCatalogPhrase, mapGraphInsightsToCatalogPhrases, mapRecommendationToCatalogPhrase, mapTextToCatalogPhrase, } from "./cardObservationCatalog.js";
+import { formatCardAreaLabels } from "./formatCardAreaLabels.js";
+import { selectTopAffectedAreas } from "./selectTopAffectedAreas.js";
+const SOURCE_WEIGHT = {
+    recommendation: 100,
+    explain: 80,
+    finding: 60,
+    graph: 50,
+    contribution: 45,
+    summary: 20,
+    area: 15,
+};
+let rankCounter = 0;
+function nextRank() {
+    rankCounter += 1;
+    return rankCounter;
+}
+function addCandidate(bucket, candidate) {
+    bucket.push({ ...candidate, rank: nextRank() });
+}
+function collectCandidates(result) {
+    const candidates = [];
+    rankCounter = 0;
+    const recs = sortRecommendationsForDisplay(Array.isArray(result.recommendations) ? result.recommendations : []);
+    for (const rec of recs) {
+        const mapped = mapRecommendationToCatalogPhrase(rec);
+        if (mapped) {
+            addCandidate(candidates, {
+                ...mapped,
+                weight: SOURCE_WEIGHT.recommendation,
+            });
+        }
+    }
+    if (Array.isArray(result.explain?.reasons)) {
+        const sorted = [...result.explain.reasons]
+            .filter((r) => r.title)
+            .sort((a, b) => Math.abs(b.scoreImpact ?? 0) - Math.abs(a.scoreImpact ?? 0));
+        for (const reason of sorted) {
+            const mapped = mapExplainReasonToCatalogPhrase(reason);
+            if (mapped) {
+                addCandidate(candidates, {
+                    ...mapped,
+                    weight: SOURCE_WEIGHT.explain,
+                });
+            }
+        }
+    }
+    if (Array.isArray(result.findings)) {
+        const severityOrder = { critical: 4, high: 3, medium: 2, low: 1 };
+        const sortedFindings = [...result.findings].sort((a, b) => (severityOrder[b.severity] ?? 0) - (severityOrder[a.severity] ?? 0));
+        for (const finding of sortedFindings) {
+            const mapped = mapFindingToCatalogPhrase(finding);
+            if (mapped) {
+                addCandidate(candidates, {
+                    ...mapped,
+                    weight: SOURCE_WEIGHT.finding,
+                });
+            }
+        }
+    }
+    for (const mapped of mapGraphInsightsToCatalogPhrases(result.graphInsights)) {
+        addCandidate(candidates, {
+            ...mapped,
+            weight: SOURCE_WEIGHT.graph,
+        });
+    }
+    if (Array.isArray(result.contributions)) {
+        for (const c of result.contributions) {
+            const mapped = mapContributionToCatalogPhrase(c.id);
+            if (mapped) {
+                addCandidate(candidates, {
+                    ...mapped,
+                    weight: SOURCE_WEIGHT.contribution,
+                });
+            }
+        }
+    }
+    const reasoning = result.decision?.reasoning;
+    if (Array.isArray(reasoning)) {
+        for (const line of reasoning) {
+            const mapped = mapTextToCatalogPhrase(line);
+            if (mapped) {
+                addCandidate(candidates, {
+                    ...mapped,
+                    weight: SOURCE_WEIGHT.summary,
+                });
+            }
+        }
+    }
+    if (Array.isArray(result.insights)) {
+        for (const ins of result.insights) {
+            const mapped = mapTextToCatalogPhrase(ins.message);
+            if (mapped) {
+                addCandidate(candidates, {
+                    ...mapped,
+                    weight: SOURCE_WEIGHT.summary,
+                });
+            }
+        }
+    }
+    return candidates;
+}
+function selectObservations(candidates, max) {
+    const byFamily = new Map();
+    for (const c of candidates) {
+        const existing = byFamily.get(c.family);
+        if (!existing || c.weight > existing.weight) {
+            byFamily.set(c.family, c);
+        }
+        else if (c.weight === existing.weight && c.rank < existing.rank) {
+            byFamily.set(c.family, c);
+        }
+    }
+    const distinct = [...byFamily.values()].sort((a, b) => {
+        if (b.weight !== a.weight)
+            return b.weight - a.weight;
+        return a.rank - b.rank;
+    });
+    if (distinct.length === 0)
+        return [];
+    const topWeight = distinct[0].weight;
+    const strongFamilies = distinct.filter((c) => c.weight >= topWeight - 15 || c.weight >= SOURCE_WEIGHT.finding);
+    let take = distinct;
+    if (strongFamilies.length <= 2 && distinct.length > 2) {
+        take = distinct.slice(0, 2);
+    }
+    else if (distinct.length > max) {
+        take = distinct.slice(0, max);
+    }
+    return take.map((c) => c.phrase);
+}
+function deriveSupportingLine(result, observations, candidates) {
+    if (observations.length !== 1)
+        return null;
+    const usedPhrase = observations[0];
+    const usedFamily = candidates.find((c) => c.phrase === usedPhrase)?.family;
+    const secondCatalog = candidates.find((c) => c.phrase !== usedPhrase && c.family !== usedFamily);
+    if (secondCatalog)
+        return secondCatalog.phrase;
+    const areas = formatCardAreaLabels(selectTopAffectedAreas(result, { max: 2 }));
+    const area = areas[0];
+    if (area && area.length <= 48 && !/\d/.test(area)) {
+        return area;
+    }
+    return null;
+}
+function denormalizedFallback(mergePosture) {
+    if (mergePosture === "safe") {
+        return { operationalObservations: [], supportingLine: null };
+    }
+    if (mergePosture === "needs_review") {
+        return { operationalObservations: [], supportingLine: null };
+    }
+    return { operationalObservations: [], supportingLine: null };
+}
+/**
+ * Derive 0–3 catalog-mapped operational observations for PR dashboard cards.
+ * Primary path: silence when no mappable signals (G2).
+ */
+export function deriveCardOperationalObservations(result, options) {
+    const max = options.max ?? 3;
+    const hasFullResult = options.hasFullResult !== false;
+    if (!result) {
+        if (hasFullResult) {
+            return { operationalObservations: [], supportingLine: null };
+        }
+        return denormalizedFallback(options.mergePosture);
+    }
+    const candidates = collectCandidates(result);
+    const operationalObservations = selectObservations(candidates, max);
+    if (operationalObservations.length === 0) {
+        if (hasFullResult) {
+            return { operationalObservations: [], supportingLine: null };
+        }
+        return denormalizedFallback(options.mergePosture);
+    }
+    const supportingLine = deriveSupportingLine(result, operationalObservations, candidates);
+    return { operationalObservations, supportingLine };
+}

package/dist/deriveCardOperationalObservations.test.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=deriveCardOperationalObservations.test.d.ts.map

package/dist/deriveCardOperationalObservations.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"deriveCardOperationalObservations.test.d.ts","sourceRoot":"","sources":["../src/deriveCardOperationalObservations.test.ts"],"names":[],"mappings":""}

package/dist/deriveCardOperationalObservations.test.js

@@ -0,0 +1,268 @@
+import { describe, it, expect } from "vitest";
+import { CARD_OBSERVATION_CATALOG, containsImperativeOrActionLanguage, containsTelemetryOrDigits, isCatalogPhrase, isGenericObservation, mapRecommendationToCatalogPhrase, mapTextToCatalogPhrase, validateCatalogIntegrity, } from "./cardObservationCatalog.js";
+import { deriveCardOperationalObservations } from "./deriveCardOperationalObservations.js";
+const baseResult = {
+    totalScore: 10,
+    layerScores: {
+        security: 1,
+        maintainability: 2,
+        ecosystem: 3,
+        upgradeImpact: 4,
+    },
+    findings: [],
+    generatedAt: "2026-01-01T00:00:00.000Z",
+};
+describe("cardObservationCatalog", () => {
+    it("validates catalog integrity", () => {
+        expect(() => validateCatalogIntegrity()).not.toThrow();
+    });
+    it("keeps all catalog phrases within length and guardrails", () => {
+        for (const phrase of CARD_OBSERVATION_CATALOG) {
+            expect(isCatalogPhrase(phrase)).toBe(true);
+            expect(containsTelemetryOrDigits(phrase)).toBe(false);
+            expect(containsImperativeOrActionLanguage(phrase)).toBe(false);
+            expect(isGenericObservation(phrase)).toBe(false);
+            expect(phrase.length).toBeLessThanOrEqual(48);
+        }
+    });
+    it("maps recommendation imperatives to detection phrases", () => {
+        const mapped = mapRecommendationToCatalogPhrase({
+            id: "rec-1",
+            title: "Reduce duplicate dependency versions",
+            rationale: "Overlapping semver ranges on runtime boundary",
+            impact: "high",
+        });
+        expect(mapped?.phrase).toBe("Duplicate dependency versions detected");
+    });
+    it("maps graph.duplicates tokens to duplicate versions phrase", () => {
+        const mapped = mapTextToCatalogPhrase("graph.duplicates on runtime boundary");
+        expect(mapped?.phrase).toBe("Duplicate dependency versions detected");
+    });
+    it("rejects generic narration", () => {
+        expect(isGenericObservation("No high-confidence merge risks")).toBe(true);
+        expect(isGenericObservation("dependency concerns detected")).toBe(true);
+    });
+});
+describe("deriveCardOperationalObservations", () => {
+    it("returns silence on primary path when no mappable signals", () => {
+        const result = deriveCardOperationalObservations({
+            ...baseResult,
+            decision: {
+                recommendation: "safe",
+                confidence: "high",
+                reasoning: [
+                    "No high-confidence merge risks from this PR dependency change",
+                ],
+            },
+        }, { mergePosture: "safe", hasFullResult: true });
+        expect(result.operationalObservations).toEqual([]);
+        expect(result.supportingLine).toBeNull();
+    });
+    it("surfaces catalog phrase from explain.reasons instead of generic reasoning", () => {
+        const result = deriveCardOperationalObservations({
+            ...baseResult,
+            totalScore: 55,
+            decision: {
+                recommendation: "needs_review",
+                confidence: "medium",
+                reasoning: ["Potential runtime impact detected"],
+            },
+            explain: {
+                reasons: [
+                    {
+                        id: "graph.transitive.1",
+                        layer: "ecosystem",
+                        title: "graph.transitive volume cluster",
+                        scoreImpact: 18,
+                    },
+                ],
+            },
+        }, { mergePosture: "needs_review", hasFullResult: true });
+        expect(result.operationalObservations).toContain("High transitive dependency volume");
+        expect(result.operationalObservations.some((o) => /merge risk|runtime impact/i.test(o))).toBe(false);
+    });
+    it("maps duplicate signal from recommendation without leaking imperative title", () => {
+        const result = deriveCardOperationalObservations({
+            ...baseResult,
+            recommendations: [
+                {
+                    id: "rec-dup",
+                    title: "Reduce duplicate dependency versions",
+                    rationale: "Multiple semver majors on shared packages",
+                    impact: "high",
+                    priorityScore: 90,
+                },
+            ],
+        }, { mergePosture: "needs_review", hasFullResult: true });
+        expect(result.operationalObservations).toEqual([
+            "Duplicate dependency versions detected",
+        ]);
+        expect(result.operationalObservations.some((o) => /^reduce/i.test(o))).toBe(false);
+    });
+    it("caps at three distinct catalog phrases on fat scans", () => {
+        const fat = {
+            ...baseResult,
+            totalScore: 72,
+            recommendations: [
+                {
+                    id: "r1",
+                    title: "Reduce duplicate dependency versions",
+                    rationale: "semver overlap",
+                    impact: "high",
+                    priorityScore: 95,
+                },
+                {
+                    id: "r2",
+                    title: "Review transitive dependency surface",
+                    rationale: "graph.transitive volume",
+                    impact: "high",
+                    priorityScore: 90,
+                },
+            ],
+            explain: {
+                reasons: [
+                    {
+                        id: "g1",
+                        layer: "security",
+                        title: "graph.vulnerable packages",
+                        scoreImpact: 20,
+                    },
+                    {
+                        id: "g2",
+                        layer: "maintainability",
+                        title: "Stale releases on multiple direct dependencies",
+                        scoreImpact: 15,
+                    },
+                ],
+            },
+            graphInsights: {
+                maxDepth: 9,
+                nodes: 1500,
+                edges: 4000,
+                vulnerable: [
+                    {
+                        kind: "vulnerable",
+                        packageName: "lodash",
+                        direct: false,
+                        depth: 3,
+                    },
+                ],
+                hotspots: Array.from({ length: 5 }, (_, i) => ({
+                    kind: "hotspot",
+                    packageName: `pkg-${i}`,
+                    direct: true,
+                    depth: 1,
+                })),
+            },
+        };
+        const result = deriveCardOperationalObservations(fat, {
+            mergePosture: "risky",
+            hasFullResult: true,
+            max: 3,
+        });
+        expect(result.operationalObservations.length).toBeLessThanOrEqual(3);
+        for (const phrase of result.operationalObservations) {
+            expect(isCatalogPhrase(phrase)).toBe(true);
+            expect(containsTelemetryOrDigits(phrase)).toBe(false);
+            expect(containsImperativeOrActionLanguage(phrase)).toBe(false);
+        }
+        expect(result.supportingLine).toBeNull();
+    });
+    it("prefers one to two observations when one family dominates", () => {
+        const result = deriveCardOperationalObservations({
+            ...baseResult,
+            explain: {
+                reasons: [
+                    {
+                        id: "t1",
+                        layer: "ecosystem",
+                        title: "graph.transitive volume cluster 1",
+                        scoreImpact: 30,
+                    },
+                    {
+                        id: "t2",
+                        layer: "ecosystem",
+                        title: "graph.transitive volume cluster 2",
+                        scoreImpact: 25,
+                    },
+                    {
+                        id: "t3",
+                        layer: "ecosystem",
+                        title: "graph.transitive volume cluster 3",
+                        scoreImpact: 20,
+                    },
+                ],
+            },
+        }, { mergePosture: "needs_review", hasFullResult: true });
+        expect(result.operationalObservations).toEqual([
+            "High transitive dependency volume",
+        ]);
+    });
+    it("omits supporting line when three observations are shown", () => {
+        const result = deriveCardOperationalObservations({
+            ...baseResult,
+            recommendations: [
+                {
+                    id: "r1",
+                    title: "Reduce duplicate dependency versions",
+                    rationale: "dup",
+                    impact: "high",
+                    priorityScore: 95,
+                },
+            ],
+            explain: {
+                reasons: [
+                    {
+                        id: "e1",
+                        layer: "security",
+                        title: "graph.vulnerable",
+                        scoreImpact: 20,
+                    },
+                    {
+                        id: "e2",
+                        layer: "upgradeImpact",
+                        title: "Large upgrade blast radius",
+                        scoreImpact: 18,
+                    },
+                ],
+            },
+        }, { mergePosture: "risky", hasFullResult: true });
+        if (result.operationalObservations.length === 3) {
+            expect(result.supportingLine).toBeNull();
+        }
+    });
+    it("allows supporting line only with exactly one observation", () => {
+        const result = deriveCardOperationalObservations({
+            ...baseResult,
+            recommendations: [
+                {
+                    id: "r1",
+                    title: "Reduce duplicate dependency versions",
+                    rationale: "dup",
+                    impact: "high",
+                    priorityScore: 95,
+                },
+            ],
+            explain: {
+                reasons: [
+                    {
+                        id: "e1",
+                        layer: "security",
+                        title: "graph.vulnerable packages in tree",
+                        scoreImpact: 10,
+                    },
+                ],
+            },
+        }, { mergePosture: "needs_review", hasFullResult: true });
+        if (result.operationalObservations.length === 1) {
+            expect(result.supportingLine).toBe("Vulnerable transitive packages detected");
+        }
+    });
+    it("returns silence on denormalized path without signals", () => {
+        const result = deriveCardOperationalObservations(null, {
+            mergePosture: "safe",
+            hasFullResult: false,
+        });
+        expect(result.operationalObservations).toEqual([]);
+    });
+});

package/dist/deriveRiskScoreSummary.d.ts

@@ -0,0 +1,33 @@
+import type { ScanResult, ScoreLayer } from "./types.js";
+export declare const SCAN_DETAIL_RISK_BAND_MODERATE_MIN = 40;
+export declare const SCAN_DETAIL_RISK_BAND_HIGH_MIN = 80;
+export type ScanDetailOverallRiskBand = "low" | "moderate" | "high";
+export type ScanDetailLayerConcernLevel = "low" | "medium" | "high";
+export type ScanDetailSignalLayer = {
+    layer: ScoreLayer;
+    label: string;
+    score: number;
+    concernLevel: ScanDetailLayerConcernLevel;
+    concernLabel: string;
+};
+/** @deprecated Use ScanDetailSignalLayer */
+export type ScanDetailRiskLayer = ScanDetailSignalLayer;
+export type RiskScoreGaugeModel = {
+    fillPercent: number;
+    band: ScanDetailOverallRiskBand;
+    ariaLabel: string;
+};
+export type ScanDetailSignalSummary = {
+    score: number;
+    overallBand: ScanDetailOverallRiskBand;
+    overallLabel: string;
+    gauge: RiskScoreGaugeModel;
+    layers: ScanDetailSignalLayer[];
+};
+/** @deprecated Use ScanDetailSignalSummary */
+export type ScanDetailRiskSummary = ScanDetailSignalSummary;
+export declare function deriveOverallRiskBand(score: number | null | undefined): ScanDetailOverallRiskBand;
+export declare function overallSignalBandLabel(band: ScanDetailOverallRiskBand): string;
+export declare function deriveRiskScoreGauge(score: number, band: ScanDetailOverallRiskBand): RiskScoreGaugeModel;
+export declare function deriveSignalSummary(result: ScanResult): ScanDetailSignalSummary | null;
+//# sourceMappingURL=deriveRiskScoreSummary.d.ts.map

package/dist/deriveRiskScoreSummary.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"deriveRiskScoreSummary.d.ts","sourceRoot":"","sources":["../src/deriveRiskScoreSummary.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,UAAU,EAAE,UAAU,EAAE,MAAM,YAAY,CAAC;AAEzD,eAAO,MAAM,kCAAkC,KAAK,CAAC;AACrD,eAAO,MAAM,8BAA8B,KAAK,CAAC;AAgBjD,MAAM,MAAM,yBAAyB,GAAG,KAAK,GAAG,UAAU,GAAG,MAAM,CAAC;AACpE,MAAM,MAAM,2BAA2B,GAAG,KAAK,GAAG,QAAQ,GAAG,MAAM,CAAC;AAEpE,MAAM,MAAM,qBAAqB,GAAG;IAClC,KAAK,EAAE,UAAU,CAAC;IAClB,KAAK,EAAE,MAAM,CAAC;IACd,KAAK,EAAE,MAAM,CAAC;IACd,YAAY,EAAE,2BAA2B,CAAC;IAC1C,YAAY,EAAE,MAAM,CAAC;CACtB,CAAC;AAEF,4CAA4C;AAC5C,MAAM,MAAM,mBAAmB,GAAG,qBAAqB,CAAC;AAExD,MAAM,MAAM,mBAAmB,GAAG;IAChC,WAAW,EAAE,MAAM,CAAC;IACpB,IAAI,EAAE,yBAAyB,CAAC;IAChC,SAAS,EAAE,MAAM,CAAC;CACnB,CAAC;AAEF,MAAM,MAAM,uBAAuB,GAAG;IACpC,KAAK,EAAE,MAAM,CAAC;IACd,WAAW,EAAE,yBAAyB,CAAC;IACvC,YAAY,EAAE,MAAM,CAAC;IACrB,KAAK,EAAE,mBAAmB,CAAC;IAC3B,MAAM,EAAE,qBAAqB,EAAE,CAAC;CACjC,CAAC;AAEF,8CAA8C;AAC9C,MAAM,MAAM,qBAAqB,GAAG,uBAAuB,CAAC;AAO5D,wBAAgB,qBAAqB,CACnC,KAAK,EAAE,MAAM,GAAG,IAAI,GAAG,SAAS,GAC/B,yBAAyB,CAM3B;AAED,wBAAgB,sBAAsB,CACpC,IAAI,EAAE,yBAAyB,GAC9B,MAAM,CAKR;AAgBD,wBAAgB,oBAAoB,CAClC,KAAK,EAAE,MAAM,EACb,IAAI,EAAE,yBAAyB,GAC9B,mBAAmB,CASrB;AAED,wBAAgB,mBAAmB,CACjC,MAAM,EAAE,UAAU,GACjB,uBAAuB,GAAG,IAAI,CAoChC"}

package/dist/deriveRiskScoreSummary.js

@@ -0,0 +1,90 @@
+import { layerRiskBandLabel } from "./actionsStepSummary.js";
+import { scanSurfaceCopy } from "./scanSurfaceCopy.js";
+export const SCAN_DETAIL_RISK_BAND_MODERATE_MIN = 40;
+export const SCAN_DETAIL_RISK_BAND_HIGH_MIN = 80;
+const LAYER_ORDER = [
+    "security",
+    "maintainability",
+    "ecosystem",
+    "upgradeImpact",
+];
+const LAYER_LABEL = {
+    security: "Security",
+    maintainability: "Maintainability",
+    ecosystem: "Ecosystem",
+    upgradeImpact: "Upgrade Impact",
+};
+function clampScore(score) {
+    if (!Number.isFinite(score))
+        return 0;
+    return Math.max(0, Math.min(100, Math.round(score)));
+}
+export function deriveOverallRiskBand(score) {
+    if (score == null || !Number.isFinite(score))
+        return "low";
+    const value = clampScore(score);
+    if (value >= SCAN_DETAIL_RISK_BAND_HIGH_MIN)
+        return "high";
+    if (value >= SCAN_DETAIL_RISK_BAND_MODERATE_MIN)
+        return "moderate";
+    return "low";
+}
+export function overallSignalBandLabel(band) {
+    const copy = scanSurfaceCopy.scanDetail.signalSummary.bandLabel;
+    if (band === "high")
+        return copy.high;
+    if (band === "moderate")
+        return copy.moderate;
+    return copy.low;
+}
+function layerBandToSignal(band) {
+    const copy = scanSurfaceCopy.scanDetail.signalSummary.signalLabel;
+    if (band === "High") {
+        return { level: "high", label: copy.high };
+    }
+    if (band === "Moderate") {
+        return { level: "medium", label: copy.medium };
+    }
+    return { level: "low", label: copy.low };
+}
+export function deriveRiskScoreGauge(score, band) {
+    const clamped = clampScore(score);
+    return {
+        fillPercent: clamped,
+        band,
+        ariaLabel: scanSurfaceCopy.scanDetail.signalSummary.gaugeAriaLabel
+            .replace("{score}", String(clamped))
+            .replace("{band}", overallSignalBandLabel(band)),
+    };
+}
+export function deriveSignalSummary(result) {
+    if (typeof result.totalScore !== "number" ||
+        !Number.isFinite(result.totalScore)) {
+        return null;
+    }
+    const score = clampScore(result.totalScore);
+    const overallBand = deriveOverallRiskBand(score);
+    const overallLabel = overallSignalBandLabel(overallBand);
+    const gauge = deriveRiskScoreGauge(score, overallBand);
+    const layers = LAYER_ORDER.map((layer) => {
+        const layerScore = typeof result.layerScores?.[layer] === "number"
+            ? clampScore(result.layerScores[layer])
+            : 0;
+        const band = layerRiskBandLabel(layerScore);
+        const signal = layerBandToSignal(band);
+        return {
+            layer,
+            label: LAYER_LABEL[layer],
+            score: layerScore,
+            concernLevel: signal.level,
+            concernLabel: signal.label,
+        };
+    });
+    return {
+        score,
+        overallBand,
+        overallLabel,
+        gauge,
+        layers,
+    };
+}

package/dist/deriveRiskScoreSummary.test.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=deriveRiskScoreSummary.test.d.ts.map

package/dist/deriveRiskScoreSummary.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"deriveRiskScoreSummary.test.d.ts","sourceRoot":"","sources":["../src/deriveRiskScoreSummary.test.ts"],"names":[],"mappings":""}

package/dist/deriveRiskScoreSummary.test.js

@@ -0,0 +1,47 @@
+import { describe, expect, it } from "vitest";
+import { deriveOverallRiskBand, deriveSignalSummary, SCAN_DETAIL_RISK_BAND_HIGH_MIN, SCAN_DETAIL_RISK_BAND_MODERATE_MIN, } from "./deriveRiskScoreSummary.js";
+const baseResult = {
+    totalScore: 71,
+    layerScores: {
+        security: 80,
+        maintainability: 65,
+        ecosystem: 55,
+        upgradeImpact: 70,
+    },
+    findings: [],
+    generatedAt: "2026-01-01T00:00:00.000Z",
+};
+describe("deriveOverallRiskBand", () => {
+    it("uses 40/80 thresholds", () => {
+        expect(SCAN_DETAIL_RISK_BAND_MODERATE_MIN).toBe(40);
+        expect(SCAN_DETAIL_RISK_BAND_HIGH_MIN).toBe(80);
+        expect(deriveOverallRiskBand(39)).toBe("low");
+        expect(deriveOverallRiskBand(40)).toBe("moderate");
+        expect(deriveOverallRiskBand(71)).toBe("moderate");
+        expect(deriveOverallRiskBand(79)).toBe("moderate");
+        expect(deriveOverallRiskBand(80)).toBe("high");
+    });
+});
+describe("deriveSignalSummary", () => {
+    it("returns moderate band for score 71 on safe posture", () => {
+        const summary = deriveSignalSummary({
+            ...baseResult,
+            decision: { recommendation: "safe", confidence: "high", reasoning: [] },
+        });
+        expect(summary?.score).toBe(71);
+        expect(summary?.overallBand).toBe("moderate");
+        expect(summary?.overallLabel).toBe("Moderate");
+        expect(summary?.gauge.fillPercent).toBe(71);
+    });
+    it("returns null when totalScore is missing", () => {
+        expect(deriveSignalSummary({
+            ...baseResult,
+            totalScore: Number.NaN,
+        })).toBeNull();
+    });
+    it("uses short signal labels on layer rows", () => {
+        const summary = deriveSignalSummary(baseResult);
+        expect(summary?.layers).toHaveLength(4);
+        expect(summary?.layers[0]?.concernLabel).toBe("Elevated");
+    });
+});