@mergesignal/shared 0.12.2 → 0.13.0

package/dist/presentation/abi3Expression.test.js

@@ -1,392 +0,0 @@
-/**
- * Wave 2.D — ABI 3 expression validation.
- *
- * Validates that:
- * 1. projectReasoningLines reads from assessment.reasoning (ABI 3) when present
- * 2. projectVerificationActions returns assessment.verificationScope.guidance when present
- * 3. PR comment includes reviewFocalPoint.electionSummary when present
- * 4. Check run "Why" section uses assessment.reasoning lines directly
- * 5. No prohibited vocabulary appears in rendered surfaces
- * 6. assessment.reasoning takes priority over decision.reasoning
- */
-import { describe, expect, it } from "vitest";
-import { minimalReviewFocalPoint, reachScopeFor, verificationScopeFor, withAssessmentScope, } from "../fixtures/assessmentScopeFixtures.js";
-import { projectReasoningLines, projectVerificationActions, } from "../assessmentProjection.js";
-import { toPublicPresentation } from "../assessmentPresentationUtils.js";
-import { projectAssessmentFields } from "./projectAssessmentFields.js";
-import { buildScanPresentationBundle } from "./orchestration/buildScanPresentationBundle.js";
-import { presentGitHubPrComment } from "./presenters/presentGitHubPrComment.js";
-import { presentGitHubCheckRun } from "./presenters/presentGitHubCheckRun.js";
-import { buildGitHubCheckRunOutput } from "./buildGitHubCheckRunOutput.js";
-import { presentGitHubPrCommentMarkdownFromResult } from "../presentGitHubPrComment.js";
-// ---------------------------------------------------------------------------
-// ABI 3 — Canonical express/confirmed_runtime_usage fixture
-// ---------------------------------------------------------------------------
-const expressReasoning = [
-    "express is used in HTTP request handling in this repository via middleware chains.",
-    "Import paths to application entry points were directly observed.",
-    "Verification is required: review HTTP route definitions and middleware implementation.",
-];
-const expressGuidance = [
-    "Review HTTP route definitions and middleware implementation in src/app.ts and src/server.ts.",
-    "Review handler implementations that use express routing.",
-];
-const expressElectionSummary = "express was selected as the primary review anchor because it has the highest repository reach among changed packages and confirmed runtime usage in HTTP request handling.";
-const assessmentExpressAbi3 = withAssessmentScope({
-    posture: "needs_review",
-    confidence: "high",
-    primaryConcern: "confirmed_runtime_usage",
-    concerns: [
-        {
-            kind: "confirmed_runtime_usage",
-            rank: 1,
-            packages: ["express"],
-            evidenceRefs: ["fixture:express"],
-            context: "express participates in HTTP request handling across 12 files.",
-        },
-    ],
-    factors: ["confirmed_runtime_usage", "http_framework_infrastructure"],
-    changeClasses: ["runtime_upgrade"],
-    presentation: {
-        narrativeIntensity: "elevated",
-        reachVisibility: "prominent",
-        verificationIntensity: "required",
-        insightEmissionFloor: "full",
-        reportMode: "high_signal_pr",
-    },
-    reasoning: expressReasoning,
-    confidenceRationale: "Confidence is high: propagation from express to application entry points was directly observed.",
-}, {
-    reviewFocalPoint: {
-        ...minimalReviewFocalPoint(["express"]),
-        electionSummary: expressElectionSummary,
-    },
-    reachScope: reachScopeFor(["express"], "high"),
-    verificationScope: verificationScopeFor(["express"], ["routes", "middleware"], undefined),
-});
-const assessmentExpressAbi3WithGuidance = {
-    ...assessmentExpressAbi3,
-    verificationScope: {
-        ...assessmentExpressAbi3.verificationScope,
-        guidance: expressGuidance,
-    },
-};
-function scanResultWithAssessment(assessment, overrides = {}) {
-    return {
-        totalScore: 63,
-        layerScores: {
-            security: 10,
-            maintainability: 20,
-            ecosystem: 30,
-            upgradeImpact: 15,
-        },
-        findings: [],
-        generatedAt: "2026-01-01T00:00:00.000Z",
-        changedPackages: ["express"],
-        assessment,
-        decision: {
-            recommendation: "needs_review",
-            confidence: "high",
-            reasoning: ["Old generic decision reasoning — should not appear."],
-        },
-        ...overrides,
-    };
-}
-// ---------------------------------------------------------------------------
-// projectReasoningLines — ABI 3 priority
-// ---------------------------------------------------------------------------
-describe("projectReasoningLines — ABI 3", () => {
-    it("returns assessment.reasoning when present (ABI 3 takes priority)", () => {
-        const result = scanResultWithAssessment(assessmentExpressAbi3);
-        const lines = projectReasoningLines(result);
-        expect(lines).toEqual(expressReasoning);
-    });
-    it("assessment.reasoning takes priority over decision.reasoning", () => {
-        const result = scanResultWithAssessment(assessmentExpressAbi3);
-        const lines = projectReasoningLines(result);
-        expect(lines).not.toContain("Old generic decision reasoning — should not appear.");
-    });
-    it("falls back to decision.reasoning when assessment.reasoning is empty", () => {
-        const assessmentWithoutReasoning = {
-            ...assessmentExpressAbi3,
-            reasoning: [],
-        };
-        const result = scanResultWithAssessment(assessmentWithoutReasoning);
-        const lines = projectReasoningLines(result);
-        expect(lines).toEqual([
-            "Old generic decision reasoning — should not appear.",
-        ]);
-    });
-    it("returns empty array when both reasoning sources are absent", () => {
-        const assessmentEmpty = {
-            ...assessmentExpressAbi3,
-            reasoning: [],
-        };
-        const result = scanResultWithAssessment(assessmentEmpty, {
-            decision: {
-                recommendation: "needs_review",
-                confidence: "high",
-                reasoning: [],
-            },
-        });
-        const lines = projectReasoningLines(result);
-        expect(lines).toEqual([]);
-    });
-    it("reasoning lines contain no prohibited vocabulary", () => {
-        const result = scanResultWithAssessment(assessmentExpressAbi3);
-        const lines = projectReasoningLines(result);
-        const joined = lines.join(" ");
-        const prohibited = [
-            "qualityClass",
-            "qualityBasis",
-            "proofFingerprint",
-            "observationId",
-            "propagationQualityRank",
-            "AssessmentEvidenceBundle",
-            "DenseEvidenceHighlight",
-            "will affect",
-            "will break",
-            "breaks compatibility",
-            "remain compatible",
-            "critical path",
-        ];
-        for (const term of prohibited) {
-            expect(joined).not.toContain(term);
-        }
-    });
-});
-// ---------------------------------------------------------------------------
-// projectVerificationActions — guidance priority
-// ---------------------------------------------------------------------------
-describe("projectVerificationActions — ABI 3 guidance", () => {
-    const presentation = toPublicPresentation(assessmentExpressAbi3WithGuidance.presentation);
-    it("returns guidance prose when verificationScope.guidance is present", () => {
-        const result = scanResultWithAssessment(assessmentExpressAbi3WithGuidance);
-        const actions = projectVerificationActions(assessmentExpressAbi3WithGuidance, presentation, result, 6);
-        expect(actions).toEqual(expressGuidance);
-    });
-    it("guidance respects max limit", () => {
-        const result = scanResultWithAssessment(assessmentExpressAbi3WithGuidance);
-        const actions = projectVerificationActions(assessmentExpressAbi3WithGuidance, presentation, result, 1);
-        expect(actions).toHaveLength(1);
-        expect(actions[0]).toBe(expressGuidance[0]);
-    });
-    it("falls back to focus tokens when guidance is absent", () => {
-        const result = scanResultWithAssessment(assessmentExpressAbi3);
-        const actions = projectVerificationActions(assessmentExpressAbi3, presentation, result, 6);
-        // No guidance — falls back to runtime focus tokens
-        expect(actions).toEqual(expect.arrayContaining(["routes", "middleware"]));
-    });
-    it("returns empty when verificationIntensity is none", () => {
-        const noneAssessment = {
-            ...assessmentExpressAbi3WithGuidance,
-            presentation: {
-                ...assessmentExpressAbi3WithGuidance.presentation,
-                verificationIntensity: "none",
-            },
-        };
-        const result = scanResultWithAssessment(noneAssessment);
-        const actions = projectVerificationActions(noneAssessment, toPublicPresentation(noneAssessment.presentation), result, 6);
-        expect(actions).toEqual([]);
-    });
-});
-// ---------------------------------------------------------------------------
-// projectAssessmentFields — ABI 3 expression projection
-// ---------------------------------------------------------------------------
-describe("projectAssessmentFields — ABI 3 expression", () => {
-    it("projects confidenceRationale and electionSummary from assessment", () => {
-        const result = scanResultWithAssessment(assessmentExpressAbi3);
-        const bundle = buildScanPresentationBundle({
-            result,
-            pipelineStatus: "done",
-        });
-        const fields = projectAssessmentFields(bundle);
-        expect(fields.confidenceRationale).toBe("Confidence is high: propagation from express to application entry points was directly observed.");
-        expect(fields.electionSummary).toBe(expressElectionSummary);
-        expect(fields.reasoning).toEqual(expressReasoning);
-    });
-    it("omits empty confidenceRationale and electionSummary after trim", () => {
-        const assessment = {
-            ...assessmentExpressAbi3,
-            confidenceRationale: "   ",
-            reviewFocalPoint: {
-                ...assessmentExpressAbi3.reviewFocalPoint,
-                electionSummary: "",
-            },
-        };
-        const result = scanResultWithAssessment(assessment);
-        const bundle = buildScanPresentationBundle({
-            result,
-            pipelineStatus: "done",
-        });
-        const fields = projectAssessmentFields(bundle);
-        expect(fields.confidenceRationale).toBeUndefined();
-        expect(fields.electionSummary).toBeUndefined();
-    });
-    it("projects reasoning when assessment has concerns", () => {
-        const result = scanResultWithAssessment(assessmentExpressAbi3);
-        const bundle = buildScanPresentationBundle({
-            result,
-            pipelineStatus: "done",
-        });
-        const fields = projectAssessmentFields(bundle);
-        expect(assessmentExpressAbi3.concerns.length).toBeGreaterThan(0);
-        expect(fields.reasoning.length).toBeGreaterThan(0);
-        expect(fields.reasoning).toEqual(expressReasoning);
-    });
-});
-// ---------------------------------------------------------------------------
-// PR comment — electionSummary and reasoning
-// ---------------------------------------------------------------------------
-describe("presentGitHubPrComment — ABI 3 expression", () => {
-    function buildBundle(assessment) {
-        const result = scanResultWithAssessment(assessment, {
-            changedPackages: ["express"],
-        });
-        return buildScanPresentationBundle({ result, pipelineStatus: "done" });
-    }
-    it("introLines include electionSummary when present", () => {
-        const bundle = buildBundle(assessmentExpressAbi3);
-        const comment = presentGitHubPrComment(bundle);
-        expect(comment.introLines).toContain(expressElectionSummary);
-    });
-    it("introLines include assessment.reasoning sentences", () => {
-        const bundle = buildBundle(assessmentExpressAbi3);
-        const comment = presentGitHubPrComment(bundle);
-        const joined = comment.introLines.join(" ");
-        expect(joined).toContain("express is used in HTTP request handling");
-        expect(joined).toContain("Import paths to application entry points");
-    });
-    it("electionSummary is absent from introLines when not set", () => {
-        const assessmentNoElection = {
-            ...assessmentExpressAbi3,
-            reviewFocalPoint: {
-                ...assessmentExpressAbi3.reviewFocalPoint,
-                electionSummary: undefined,
-            },
-        };
-        const bundle = buildBundle(assessmentNoElection);
-        const comment = presentGitHubPrComment(bundle);
-        expect(comment.introLines).not.toContain(expressElectionSummary);
-    });
-    it("introLines contain no prohibited vocabulary", () => {
-        const bundle = buildBundle(assessmentExpressAbi3);
-        const comment = presentGitHubPrComment(bundle);
-        const joined = comment.introLines.join(" ");
-        const prohibited = [
-            "qualityClass",
-            "qualityBasis",
-            "proofFingerprint",
-            "observationId",
-            "propagationQualityRank",
-        ];
-        for (const term of prohibited) {
-            expect(joined).not.toContain(term);
-        }
-    });
-});
-// ---------------------------------------------------------------------------
-// Check run — Why section uses assessment.reasoning
-// ---------------------------------------------------------------------------
-describe("presentGitHubCheckRun — ABI 3 Why section", () => {
-    const SCAN_ID = "scan-abi3-test";
-    const ORIGIN = "https://app.test";
-    function buildBundle(assessment) {
-        const result = scanResultWithAssessment(assessment, {
-            changedPackages: ["express"],
-        });
-        return buildScanPresentationBundle({ result, pipelineStatus: "done" });
-    }
-    it("Why section bullets come from assessment.reasoning (ABI 3)", () => {
-        const bundle = buildBundle(assessmentExpressAbi3);
-        const checkRun = presentGitHubCheckRun(bundle, {
-            scanId: SCAN_ID,
-            webAppOrigin: ORIGIN,
-        });
-        const whySection = checkRun.sections.find((s) => s.id === "why" && s.title === "Why");
-        expect(whySection).toBeDefined();
-        expect(whySection.bullets).toEqual(expect.arrayContaining([
-            "express is used in HTTP request handling in this repository via middleware chains.",
-        ]));
-    });
-    it("Why section does not contain old generic decision reasoning", () => {
-        const bundle = buildBundle(assessmentExpressAbi3);
-        const checkRun = presentGitHubCheckRun(bundle, {
-            scanId: SCAN_ID,
-            webAppOrigin: ORIGIN,
-        });
-        const whySection = checkRun.sections.find((s) => s.id === "why" && s.title === "Why");
-        const bulletText = whySection?.bullets.join(" ") ?? "";
-        expect(bulletText).not.toContain("Old generic decision reasoning");
-    });
-    it("check run summary contains no prohibited vocabulary", () => {
-        const result = scanResultWithAssessment(assessmentExpressAbi3, {
-            changedPackages: ["express"],
-            methodologyVersion: "mergesignal-engine/test",
-        });
-        const output = buildGitHubCheckRunOutput(result, {
-            scanId: SCAN_ID,
-            webAppOrigin: ORIGIN,
-        });
-        const prohibited = [
-            "qualityClass",
-            "qualityBasis",
-            "proofFingerprint",
-            "observationId",
-            "propagationQualityRank",
-            "AssessmentEvidenceBundle",
-        ];
-        for (const term of prohibited) {
-            expect(output.summary).not.toContain(term);
-        }
-    });
-    it("Why section respects 3-line limit", () => {
-        const bundle = buildBundle(assessmentExpressAbi3);
-        const checkRun = presentGitHubCheckRun(bundle, {
-            scanId: SCAN_ID,
-            webAppOrigin: ORIGIN,
-        });
-        const whySection = checkRun.sections.find((s) => s.title === "Why");
-        if (whySection) {
-            expect(whySection.bullets.length).toBeLessThanOrEqual(3);
-        }
-    });
-});
-// ---------------------------------------------------------------------------
-// End-to-end markdown snapshot — PR comment with ABI 3 fixture
-// ---------------------------------------------------------------------------
-describe("PR comment markdown — ABI 3 end-to-end", () => {
-    it("rendered markdown includes repository-specific reasoning", () => {
-        const result = scanResultWithAssessment(assessmentExpressAbi3, {
-            changedPackages: ["express"],
-        });
-        const markdown = presentGitHubPrCommentMarkdownFromResult(result);
-        expect(markdown).toContain("express is used in HTTP request handling");
-        expect(markdown).toContain("Import paths to application entry points");
-    });
-    it("rendered markdown includes electionSummary", () => {
-        const result = scanResultWithAssessment(assessmentExpressAbi3, {
-            changedPackages: ["express"],
-        });
-        const markdown = presentGitHubPrCommentMarkdownFromResult(result);
-        expect(markdown).toContain("express was selected as the primary review anchor");
-    });
-    it("rendered markdown contains no prohibited vocabulary", () => {
-        const result = scanResultWithAssessment(assessmentExpressAbi3, {
-            changedPackages: ["express"],
-        });
-        const markdown = presentGitHubPrCommentMarkdownFromResult(result);
-        const prohibited = [
-            "qualityClass",
-            "qualityBasis",
-            "proofFingerprint",
-            "observationId",
-            "propagationQualityRank",
-            "AssessmentEvidenceBundle",
-            "DenseEvidenceHighlight",
-        ];
-        for (const term of prohibited) {
-            expect(markdown).not.toContain(term);
-        }
-    });
-});

package/dist/presentation/buildGitHubCheckRunOutput.test.d.ts

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

package/dist/presentation/buildGitHubCheckRunOutput.test.d.ts.map

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

package/dist/presentation/buildGitHubCheckRunOutput.test.js

@@ -1,163 +0,0 @@
-import { describe, expect, it } from "vitest";
-import { assessmentFastifyRuntime, assessmentTypescriptPatch, } from "../fixtures/assessmentFixtures.js";
-import { withAssessmentScope, minimalReviewFocalPoint, emptyReachScope, emptyVerificationScope, reachScopeFor, } from "../fixtures/assessmentScopeFixtures.js";
-import { buildScanPresentationBundle, presentDashboardCard } from "./index.js";
-import { buildGitHubCheckRunOutput } from "./buildGitHubCheckRunOutput.js";
-const safeAssessment = assessmentTypescriptPatch;
-const baselineAssessment = withAssessmentScope({
-    posture: "safe",
-    confidence: "medium",
-    primaryConcern: "graph_baseline_only",
-    concerns: [
-        {
-            kind: "graph_baseline_only",
-            rank: 1,
-            evidenceRefs: ["fixture:baseline"],
-        },
-    ],
-    factors: ["graph_baseline_only"],
-    changeClasses: ["tooling_maintenance"],
-    presentation: {
-        narrativeIntensity: "minimal",
-        reachVisibility: "hidden",
-        verificationIntensity: "none",
-        insightEmissionFloor: "none",
-        reportMode: "lightweight_pr_graph_baseline",
-    },
-}, {
-    reviewFocalPoint: minimalReviewFocalPoint(["@types/minimist"]),
-    reachScope: emptyReachScope(),
-    verificationScope: emptyVerificationScope(),
-});
-const needsReviewAssessment = assessmentFastifyRuntime;
-const riskyAssessment = withAssessmentScope({
-    posture: "risky",
-    confidence: "high",
-    primaryConcern: "breaking_or_major",
-    concerns: [
-        {
-            kind: "breaking_or_major",
-            rank: 1,
-            packages: ["react"],
-            evidenceRefs: ["fixture:breaking"],
-        },
-    ],
-    factors: ["breaking_or_major"],
-    changeClasses: ["breaking_change"],
-    presentation: {
-        narrativeIntensity: "elevated",
-        reachVisibility: "prominent",
-        verificationIntensity: "required",
-        insightEmissionFloor: "full",
-        reportMode: "high_signal_pr",
-    },
-}, {
-    reviewFocalPoint: minimalReviewFocalPoint(["react"]),
-    reachScope: reachScopeFor(["react"], "high"),
-    verificationScope: emptyVerificationScope(),
-});
-function assertNoLegacyCheckRunMarkers(summary) {
-    expect(summary).not.toContain("Risk index");
-    expect(summary).not.toContain("Layer scores");
-    expect(summary).not.toContain("<details>");
-    expect(summary).not.toMatch(/\d+\/100/);
-}
-function minimalScanResult(overrides = {}) {
-    return {
-        totalScore: 72,
-        layerScores: {
-            security: 10,
-            maintainability: 20,
-            ecosystem: 30,
-            upgradeImpact: 15,
-        },
-        findings: [],
-        methodologyVersion: "mergesignal-engine/test",
-        generatedAt: new Date().toISOString(),
-        assessment: safeAssessment,
-        decision: {
-            recommendation: "safe",
-            confidence: "medium",
-            reasoning: [],
-        },
-        ...overrides,
-    };
-}
-describe("buildGitHubCheckRunOutput", () => {
-    it("maps safe posture to success conclusion with scan link", () => {
-        const out = buildGitHubCheckRunOutput(minimalScanResult(), {
-            scanId: "scan-safe",
-            webAppOrigin: "https://app.test",
-        });
-        expect(out.conclusion).toBe("success");
-        expect(out.summary).toContain("/scan/scan-safe");
-        expect(out.summary).toContain("Full scan:");
-        assertNoLegacyCheckRunMarkers(out.summary);
-    });
-    it("maps needs_review posture to neutral conclusion", () => {
-        const out = buildGitHubCheckRunOutput(minimalScanResult({
-            assessment: needsReviewAssessment,
-            decision: {
-                recommendation: "needs_review",
-                confidence: "medium",
-                reasoning: ["Runtime usage confirmed"],
-            },
-            changedPackages: ["fastify"],
-        }), { scanId: "scan-review", webAppOrigin: "https://app.test" });
-        expect(out.conclusion).toBe("neutral");
-        expect(out.summary).toContain("/scan/scan-review");
-        assertNoLegacyCheckRunMarkers(out.summary);
-    });
-    it("maps risky posture to failure conclusion", () => {
-        const out = buildGitHubCheckRunOutput(minimalScanResult({
-            assessment: riskyAssessment,
-            decision: {
-                recommendation: "risky",
-                confidence: "high",
-                reasoning: ["Breaking change"],
-            },
-        }), { scanId: "scan-risky", webAppOrigin: "https://app.test" });
-        expect(out.conclusion).toBe("failure");
-        assertNoLegacyCheckRunMarkers(out.summary);
-    });
-    it("produces success conclusion for lightweight baseline presentation", () => {
-        const out = buildGitHubCheckRunOutput(minimalScanResult({
-            assessment: baselineAssessment,
-            reportPresentation: { mode: "lightweight_pr_graph_baseline" },
-            changedPackages: ["@types/minimist"],
-            decision: {
-                recommendation: "safe",
-                confidence: "medium",
-                reasoning: [],
-            },
-        }), { scanId: "scan-lw", webAppOrigin: "https://app.test" });
-        expect(out.conclusion).toBe("success");
-        expect(out.summary).toContain("/scan/scan-lw");
-        assertNoLegacyCheckRunMarkers(out.summary);
-    });
-    it("throws when assessment is missing", () => {
-        expect(() => buildGitHubCheckRunOutput(minimalScanResult({ assessment: undefined }), "scan-no-assessment")).toThrow(/assessment/i);
-    });
-    it("title matches dashboard card headline from the same bundle", () => {
-        const result = minimalScanResult({
-            assessment: needsReviewAssessment,
-            decision: {
-                recommendation: "needs_review",
-                confidence: "medium",
-                reasoning: ["Runtime usage confirmed"],
-            },
-            changedPackages: ["fastify"],
-        });
-        const out = buildGitHubCheckRunOutput(result, {
-            scanId: "scan-parity",
-            webAppOrigin: "https://app.test",
-        });
-        const bundle = buildScanPresentationBundle({
-            result,
-            pipelineStatus: "done",
-        });
-        expect(bundle).not.toBeNull();
-        const card = presentDashboardCard(bundle);
-        expect(out.title).toBe(card.headline);
-    });
-});

package/dist/presentation/bundleAccessorParity.test.d.ts

@@ -1,9 +0,0 @@
-/**
- * V1 public bundle transport — ScanPresentationBundle vs contracts extractor.
- *
- * Engine OutcomePresentationBundle uses the same `extractAuthoredCommunication()`
- * from `@mergesignal/contracts`; engine-side accessor transport is covered in
- * mergesignal-engine `packages/worker/src/outcome-presentation.test.ts`.
- */
-export {};
-//# sourceMappingURL=bundleAccessorParity.test.d.ts.map

package/dist/presentation/bundleAccessorParity.test.d.ts.map

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