api-tests-coverage 1.0.0

package/dist/src/mcp/fallback/index.js

@@ -0,0 +1,216 @@
+"use strict";
+/**
+ * MCP integration – fallback AI interpreter.
+ *
+ * When MCP is disabled or unavailable this module generates a deterministic,
+ * rule-based NormalizedAiAnalysis so that pipelines never break.
+ *
+ * Outputs are fully deterministic given the same inputs, making them suitable
+ * for snapshot testing.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.generateFallbackCoverageAnalysis = generateFallbackCoverageAnalysis;
+exports.generateFallbackSecurityAnalysis = generateFallbackSecurityAnalysis;
+exports.generateFallbackIntelligenceAnalysis = generateFallbackIntelligenceAnalysis;
+exports.generateFallbackAnalysis = generateFallbackAnalysis;
+/**
+ * Generate a deterministic AI-style coverage summary without MCP.
+ */
+function generateFallbackCoverageAnalysis(input) {
+    var _a;
+    const failed = (_a = input.failedCategories) !== null && _a !== void 0 ? _a : [];
+    const allPass = failed.length === 0;
+    const summary = allPass
+        ? `All ${input.results.length} coverage categories meet or exceed their configured thresholds. ` +
+            `The overall quality gate has passed.`
+        : `${failed.length} of ${input.results.length} coverage categories failed their quality gate. ` +
+            `Immediate attention is required for: ${failed.join(', ')}.`;
+    const keyFindings = input.results.map((r) => {
+        var _a;
+        const threshold = (_a = input.thresholds) === null || _a === void 0 ? void 0 : _a[r.type];
+        const status = threshold !== undefined
+            ? r.coveragePercent >= threshold ? 'meets threshold' : 'below threshold'
+            : 'no threshold configured';
+        return `${r.type}: ${r.coveragePercent.toFixed(1)}% (${status})`;
+    });
+    const topRisks = failed.map((cat) => {
+        var _a, _b;
+        const r = input.results.find((x) => x.type === cat);
+        const threshold = (_b = (_a = input.thresholds) === null || _a === void 0 ? void 0 : _a[cat]) !== null && _b !== void 0 ? _b : 0;
+        if (!r)
+            return `${cat}: gate failed`;
+        const gap = threshold - r.coveragePercent;
+        return `${cat} coverage is ${gap.toFixed(1)}% below the required threshold`;
+    });
+    const missingCoverageAreas = input.results
+        .filter((r) => r.totalItems > r.coveredItems)
+        .map((r) => `${r.type}: ${r.totalItems - r.coveredItems} uncovered item(s)`);
+    const recommendedActions = allPass
+        ? [
+            'All gates passed — consider raising thresholds to enforce stricter coverage.',
+            'Review uncovered items and add targeted tests to reach 100%.',
+        ]
+        : [
+            ...failed.map((cat) => `Add tests to improve ${cat} coverage above the configured threshold.`),
+            'Re-run the coverage analysis after adding tests.',
+            'Consider adding coverage for critical paths first.',
+        ];
+    return {
+        summary,
+        keyFindings,
+        topRisks,
+        recommendedActions,
+        missingCoverageAreas,
+        confidence: 'high',
+        isFallback: true,
+        category: 'coverage',
+    };
+}
+/**
+ * Generate a deterministic AI-style security analysis without MCP.
+ */
+function generateFallbackSecurityAnalysis(input) {
+    var _a, _b, _c;
+    const s = input.scanSummary;
+    const criticalHigh = s.bySeverity.CRITICAL + s.bySeverity.HIGH;
+    const gatePassed = (_b = (_a = s.gateResult) === null || _a === void 0 ? void 0 : _a.passed) !== null && _b !== void 0 ? _b : true;
+    const summary = gatePassed
+        ? `Security scan completed with ${s.totalFindings} finding(s). ` +
+            `No critical or high findings exceed gate thresholds.`
+        : `Security gate FAILED. ${criticalHigh} critical/high severity finding(s) require ` +
+            `immediate remediation before this change can be merged.`;
+    const keyFindings = [
+        `Total findings: ${s.totalFindings}`,
+        `Critical: ${s.bySeverity.CRITICAL}`,
+        `High: ${s.bySeverity.HIGH}`,
+        `Medium: ${s.bySeverity.MEDIUM}`,
+        `Low: ${s.bySeverity.LOW}`,
+        `Scanners run: ${s.scannersRun.join(', ')}`,
+    ];
+    const topRisks = [];
+    if (s.bySeverity.CRITICAL > 0) {
+        topRisks.push(`${s.bySeverity.CRITICAL} CRITICAL finding(s) must be fixed immediately`);
+    }
+    if (s.bySeverity.HIGH > 0) {
+        topRisks.push(`${s.bySeverity.HIGH} HIGH finding(s) pose significant risk`);
+    }
+    if (s.bySeverity.MEDIUM > 0) {
+        topRisks.push(`${s.bySeverity.MEDIUM} MEDIUM finding(s) should be addressed soon`);
+    }
+    const likelyRootCauses = [];
+    const cats = Object.entries((_c = s.byCategory) !== null && _c !== void 0 ? _c : {})
+        .filter(([, count]) => count > 0)
+        .map(([cat]) => cat);
+    if (cats.length > 0) {
+        likelyRootCauses.push(`Findings span categories: ${cats.join(', ')}`);
+    }
+    const recommendedActions = gatePassed
+        ? [
+            'Review all remaining findings and assign remediation owners.',
+            'Consider tightening gate thresholds to catch more issues.',
+        ]
+        : [
+            'Fix all CRITICAL and HIGH findings before merging.',
+            'Re-run security scan to confirm fixes.',
+            'Review scanner configurations to reduce false positives.',
+        ];
+    return {
+        summary,
+        keyFindings,
+        topRisks,
+        recommendedActions,
+        likelyRootCauses,
+        confidence: 'high',
+        isFallback: true,
+        category: 'security',
+    };
+}
+/**
+ * Generate a deterministic AI-style intelligence analysis without MCP.
+ */
+function generateFallbackIntelligenceAnalysis(input) {
+    var _a, _b, _c;
+    const hasIssues = input.totalFindings > 0 || input.criticalUncoveredItems > 0;
+    const p0Count = (_a = input.recommendationsByPriority['P0']) !== null && _a !== void 0 ? _a : 0;
+    const p1Count = (_b = input.recommendationsByPriority['P1']) !== null && _b !== void 0 ? _b : 0;
+    const summary = hasIssues
+        ? `Coverage Intelligence identified ${input.totalFindings} functional finding(s) and ` +
+            `${input.totalRecommendations} missing test recommendation(s). ` +
+            `Maximum risk score: ${input.maxRiskScore}. ` +
+            (p0Count > 0 ? `${p0Count} P0 action(s) require immediate attention.` : '')
+        : `No functional findings detected. All analyzed coverage areas appear to be adequately tested.`;
+    const keyFindings = [
+        `Functional findings: ${input.totalFindings}`,
+        `Missing test recommendations: ${input.totalRecommendations}`,
+        `Max risk score: ${input.maxRiskScore} (avg: ${input.avgRiskScore})`,
+        `Critical uncovered items: ${input.criticalUncoveredItems}`,
+        `Unprotected security findings: ${input.unprotectedSecurityFindings}`,
+    ];
+    const topRisks = [];
+    if (p0Count > 0)
+        topRisks.push(`${p0Count} P0 recommendation(s) require urgent action`);
+    if (p1Count > 0)
+        topRisks.push(`${p1Count} P1 recommendation(s) should be addressed soon`);
+    if (input.unprotectedSecurityFindings > 0) {
+        topRisks.push(`${input.unprotectedSecurityFindings} security finding(s) lack test protection`);
+    }
+    if (input.criticalUncoveredItems > 0) {
+        topRisks.push(`${input.criticalUncoveredItems} critical flow(s) have zero test coverage`);
+    }
+    if (input.topRiskAreas && input.topRiskAreas.length > 0) {
+        topRisks.push(...input.topRiskAreas.slice(0, 3).map((a) => `High-risk area: ${a}`));
+    }
+    const missingCoverageAreas = [];
+    if (input.criticalUncoveredItems > 0) {
+        missingCoverageAreas.push(`${input.criticalUncoveredItems} critical endpoint(s)/flow(s) with no test coverage`);
+    }
+    if (input.unprotectedSecurityFindings > 0) {
+        missingCoverageAreas.push(`${input.unprotectedSecurityFindings} security finding(s) unprotected by tests`);
+    }
+    const frameworkHint = ((_c = input.frameworks) !== null && _c !== void 0 ? _c : []).length > 0
+        ? ` using ${(input.frameworks).slice(0, 2).join(' or ')}`
+        : '';
+    const recommendedActions = [];
+    if (p0Count > 0)
+        recommendedActions.push(`Address ${p0Count} P0 recommendation(s) immediately${frameworkHint}`);
+    if (p1Count > 0)
+        recommendedActions.push(`Schedule ${p1Count} P1 recommendation(s) for next sprint${frameworkHint}`);
+    if (input.unprotectedSecurityFindings > 0) {
+        recommendedActions.push('Add security-focused tests to cover unprotected scanner findings');
+    }
+    if (recommendedActions.length === 0) {
+        recommendedActions.push('Review intelligence report and schedule remaining recommendations');
+    }
+    recommendedActions.push('Re-run intelligence analysis after adding recommended tests');
+    return {
+        summary,
+        keyFindings,
+        topRisks,
+        recommendedActions,
+        missingCoverageAreas,
+        confidence: 'high',
+        isFallback: true,
+        category: 'intelligence',
+    };
+}
+// ─── Generic fallback ─────────────────────────────────────────────────────────
+/**
+ * Generate a minimal deterministic AI analysis for any coverage category.
+ */
+function generateFallbackAnalysis(category, coveragePercent, threshold) {
+    const gatePassed = threshold === undefined || coveragePercent >= threshold;
+    const summary = gatePassed
+        ? `${category} analysis passed with ${coveragePercent.toFixed(1)}% coverage.`
+        : `${category} coverage is ${coveragePercent.toFixed(1)}%, below the required ${threshold.toFixed(1)}%.`;
+    return {
+        summary,
+        keyFindings: [`Coverage: ${coveragePercent.toFixed(1)}%`],
+        topRisks: gatePassed ? [] : [`Coverage gap of ${(threshold - coveragePercent).toFixed(1)}%`],
+        recommendedActions: gatePassed
+            ? ['Maintain current coverage level.']
+            : ['Add tests to close the coverage gap.'],
+        confidence: 'high',
+        isFallback: true,
+        category,
+    };
+}

package/dist/src/mcp/index.d.ts

@@ -0,0 +1,67 @@
+/**
+ * MCP integration – public API.
+ *
+ * This is the single entry point for all MCP features.  Consumers import from
+ * here rather than from individual sub-modules.
+ *
+ * Usage example:
+ *
+ *   import { McpIntegration } from './mcp';
+ *
+ *   const mcp = new McpIntegration(config.mcp ?? {});
+ *   const analysis = await mcp.analyzeCoverage({ results, thresholds, gatePassed });
+ *   const md = mcp.renderMarkdown(analysis, 'coverage');
+ */
+import type { McpConfig, NormalizedAiAnalysis, AnalysisEvent } from './types';
+import { type CoverageSummaryPromptInput, type SecurityScanPromptInput, type PerformancePromptInput, type CompatibilityPromptInput, type CiSummaryPromptInput, type IntelligencePromptInput } from './prompts';
+import { type AiPanelData } from './templates';
+import { AnalysisEventStream } from './events';
+export type { McpConfig, McpServerConfig, McpServersConfig, McpRetryPolicy, McpTransport, AnalysisEvent, AnalysisEventType, McpPromptRequest, McpRawResponse, NormalizedAiAnalysis, AiConfidence, TemplateContext, } from './types';
+export type { CoverageSummaryPromptInput, SecurityScanPromptInput, PerformancePromptInput, CompatibilityPromptInput, CiSummaryPromptInput, IntelligencePromptInput, } from './prompts';
+export type { AiPanelData } from './templates';
+export { buildCoverageSummaryPrompt, buildSecurityScanPrompt, buildPerformancePrompt, buildCompatibilityPrompt, buildCiSummaryPrompt, buildIntelligencePrompt, } from './prompts';
+export { normalizeMcpResponse } from './normalizer';
+export { renderAiAnalysisMarkdown, renderAiAnalysisHtml, buildAiPanelData, } from './templates';
+export { generateFallbackCoverageAnalysis, generateFallbackSecurityAnalysis, generateFallbackAnalysis, generateFallbackIntelligenceAnalysis, } from './fallback';
+export { AnalysisEventStream, createNoOpStream } from './events';
+export { isMcpEnabledFor, resolveServerConfig, validateTransport, validateServerUrl, validatePayloadSize, redactSecrets, REDACTED_KEYS, MCP_DEFAULT_TIMEOUT_MS, MCP_DEFAULT_MAX_PAYLOAD_BYTES, MCP_DEFAULT_TRANSPORT, MCP_ALLOWED_TRANSPORTS, } from './config';
+export { McpClient } from './client';
+/**
+ * High-level facade that wires together the MCP client, prompts, normalizer,
+ * templates, and fallback interpreter.
+ *
+ * Instantiate with the `mcp` block from `coverage.config.json`.
+ */
+export declare class McpIntegration {
+    private readonly config;
+    private readonly client;
+    private readonly eventStream;
+    constructor(config: McpConfig);
+    /** Access the real-time event stream */
+    get events(): AnalysisEventStream;
+    /** Analyze coverage results via MCP (or fallback if unavailable) */
+    analyzeCoverage(input: CoverageSummaryPromptInput): Promise<NormalizedAiAnalysis>;
+    /** Analyze security scan results via MCP (or fallback if unavailable) */
+    analyzeSecurity(input: SecurityScanPromptInput): Promise<NormalizedAiAnalysis>;
+    /** Analyze performance / resilience coverage via MCP (or fallback) */
+    analyzePerformance(input: PerformancePromptInput): Promise<NormalizedAiAnalysis>;
+    /** Analyze compatibility / contract coverage via MCP (or fallback) */
+    analyzeCompatibility(input: CompatibilityPromptInput): Promise<NormalizedAiAnalysis>;
+    /** Generate a CI/PR summary via MCP (or fallback) */
+    analyzeCiSummary(input: CiSummaryPromptInput): Promise<NormalizedAiAnalysis>;
+    /** Analyze coverage intelligence results via MCP (or fallback if unavailable) */
+    analyzeIntelligence(input: IntelligencePromptInput): Promise<NormalizedAiAnalysis>;
+    /** Render a NormalizedAiAnalysis as Markdown */
+    renderMarkdown(analysis: NormalizedAiAnalysis, category: string, categoryTitle?: string): string;
+    /** Render a NormalizedAiAnalysis as HTML */
+    renderHtml(analysis: NormalizedAiAnalysis, category: string, categoryTitle?: string): string;
+    /** Build dashboard panel data from a NormalizedAiAnalysis */
+    buildPanelData(analysis: NormalizedAiAnalysis): AiPanelData;
+    /** Whether MCP is globally enabled */
+    isEnabled(): boolean;
+    /** Whether MCP is enabled for a specific server/category */
+    isEnabledFor(serverName: string): boolean;
+    /** Collect all buffered events */
+    getEvents(): ReadonlyArray<AnalysisEvent>;
+}
+//# sourceMappingURL=index.d.ts.map

package/dist/src/mcp/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/mcp/index.ts"],"names":[],"mappings":"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"}

package/dist/src/mcp/index.js

@@ -0,0 +1,212 @@
+"use strict";
+/**
+ * MCP integration – public API.
+ *
+ * This is the single entry point for all MCP features.  Consumers import from
+ * here rather than from individual sub-modules.
+ *
+ * Usage example:
+ *
+ *   import { McpIntegration } from './mcp';
+ *
+ *   const mcp = new McpIntegration(config.mcp ?? {});
+ *   const analysis = await mcp.analyzeCoverage({ results, thresholds, gatePassed });
+ *   const md = mcp.renderMarkdown(analysis, 'coverage');
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.McpIntegration = exports.McpClient = exports.MCP_ALLOWED_TRANSPORTS = exports.MCP_DEFAULT_TRANSPORT = exports.MCP_DEFAULT_MAX_PAYLOAD_BYTES = exports.MCP_DEFAULT_TIMEOUT_MS = exports.REDACTED_KEYS = exports.redactSecrets = exports.validatePayloadSize = exports.validateServerUrl = exports.validateTransport = exports.resolveServerConfig = exports.isMcpEnabledFor = exports.createNoOpStream = exports.AnalysisEventStream = exports.generateFallbackIntelligenceAnalysis = exports.generateFallbackAnalysis = exports.generateFallbackSecurityAnalysis = exports.generateFallbackCoverageAnalysis = exports.buildAiPanelData = exports.renderAiAnalysisHtml = exports.renderAiAnalysisMarkdown = exports.normalizeMcpResponse = exports.buildIntelligencePrompt = exports.buildCiSummaryPrompt = exports.buildCompatibilityPrompt = exports.buildPerformancePrompt = exports.buildSecurityScanPrompt = exports.buildCoverageSummaryPrompt = void 0;
+const config_1 = require("./config");
+const client_1 = require("./client");
+const prompts_1 = require("./prompts");
+const normalizer_1 = require("./normalizer");
+const templates_1 = require("./templates");
+const fallback_1 = require("./fallback");
+const events_1 = require("./events");
+var prompts_2 = require("./prompts");
+Object.defineProperty(exports, "buildCoverageSummaryPrompt", { enumerable: true, get: function () { return prompts_2.buildCoverageSummaryPrompt; } });
+Object.defineProperty(exports, "buildSecurityScanPrompt", { enumerable: true, get: function () { return prompts_2.buildSecurityScanPrompt; } });
+Object.defineProperty(exports, "buildPerformancePrompt", { enumerable: true, get: function () { return prompts_2.buildPerformancePrompt; } });
+Object.defineProperty(exports, "buildCompatibilityPrompt", { enumerable: true, get: function () { return prompts_2.buildCompatibilityPrompt; } });
+Object.defineProperty(exports, "buildCiSummaryPrompt", { enumerable: true, get: function () { return prompts_2.buildCiSummaryPrompt; } });
+Object.defineProperty(exports, "buildIntelligencePrompt", { enumerable: true, get: function () { return prompts_2.buildIntelligencePrompt; } });
+var normalizer_2 = require("./normalizer");
+Object.defineProperty(exports, "normalizeMcpResponse", { enumerable: true, get: function () { return normalizer_2.normalizeMcpResponse; } });
+var templates_2 = require("./templates");
+Object.defineProperty(exports, "renderAiAnalysisMarkdown", { enumerable: true, get: function () { return templates_2.renderAiAnalysisMarkdown; } });
+Object.defineProperty(exports, "renderAiAnalysisHtml", { enumerable: true, get: function () { return templates_2.renderAiAnalysisHtml; } });
+Object.defineProperty(exports, "buildAiPanelData", { enumerable: true, get: function () { return templates_2.buildAiPanelData; } });
+var fallback_2 = require("./fallback");
+Object.defineProperty(exports, "generateFallbackCoverageAnalysis", { enumerable: true, get: function () { return fallback_2.generateFallbackCoverageAnalysis; } });
+Object.defineProperty(exports, "generateFallbackSecurityAnalysis", { enumerable: true, get: function () { return fallback_2.generateFallbackSecurityAnalysis; } });
+Object.defineProperty(exports, "generateFallbackAnalysis", { enumerable: true, get: function () { return fallback_2.generateFallbackAnalysis; } });
+Object.defineProperty(exports, "generateFallbackIntelligenceAnalysis", { enumerable: true, get: function () { return fallback_2.generateFallbackIntelligenceAnalysis; } });
+var events_2 = require("./events");
+Object.defineProperty(exports, "AnalysisEventStream", { enumerable: true, get: function () { return events_2.AnalysisEventStream; } });
+Object.defineProperty(exports, "createNoOpStream", { enumerable: true, get: function () { return events_2.createNoOpStream; } });
+var config_2 = require("./config");
+Object.defineProperty(exports, "isMcpEnabledFor", { enumerable: true, get: function () { return config_2.isMcpEnabledFor; } });
+Object.defineProperty(exports, "resolveServerConfig", { enumerable: true, get: function () { return config_2.resolveServerConfig; } });
+Object.defineProperty(exports, "validateTransport", { enumerable: true, get: function () { return config_2.validateTransport; } });
+Object.defineProperty(exports, "validateServerUrl", { enumerable: true, get: function () { return config_2.validateServerUrl; } });
+Object.defineProperty(exports, "validatePayloadSize", { enumerable: true, get: function () { return config_2.validatePayloadSize; } });
+Object.defineProperty(exports, "redactSecrets", { enumerable: true, get: function () { return config_2.redactSecrets; } });
+Object.defineProperty(exports, "REDACTED_KEYS", { enumerable: true, get: function () { return config_2.REDACTED_KEYS; } });
+Object.defineProperty(exports, "MCP_DEFAULT_TIMEOUT_MS", { enumerable: true, get: function () { return config_2.MCP_DEFAULT_TIMEOUT_MS; } });
+Object.defineProperty(exports, "MCP_DEFAULT_MAX_PAYLOAD_BYTES", { enumerable: true, get: function () { return config_2.MCP_DEFAULT_MAX_PAYLOAD_BYTES; } });
+Object.defineProperty(exports, "MCP_DEFAULT_TRANSPORT", { enumerable: true, get: function () { return config_2.MCP_DEFAULT_TRANSPORT; } });
+Object.defineProperty(exports, "MCP_ALLOWED_TRANSPORTS", { enumerable: true, get: function () { return config_2.MCP_ALLOWED_TRANSPORTS; } });
+var client_2 = require("./client");
+Object.defineProperty(exports, "McpClient", { enumerable: true, get: function () { return client_2.McpClient; } });
+// ─── McpIntegration facade ────────────────────────────────────────────────────
+/**
+ * High-level facade that wires together the MCP client, prompts, normalizer,
+ * templates, and fallback interpreter.
+ *
+ * Instantiate with the `mcp` block from `coverage.config.json`.
+ */
+class McpIntegration {
+    constructor(config) {
+        this.config = config;
+        this.client = new client_1.McpClient(config);
+        this.eventStream = new events_1.AnalysisEventStream();
+    }
+    // ─── Event stream ───────────────────────────────────────────────────────────
+    /** Access the real-time event stream */
+    get events() {
+        return this.eventStream;
+    }
+    // ─── Analysis methods ───────────────────────────────────────────────────────
+    /** Analyze coverage results via MCP (or fallback if unavailable) */
+    async analyzeCoverage(input) {
+        if (!(0, config_1.isMcpEnabledFor)(this.config, 'coverageSummary')) {
+            const result = (0, fallback_1.generateFallbackCoverageAnalysis)({
+                results: input.results,
+                thresholds: input.thresholds,
+                gatePassed: input.gatePassed,
+                failedCategories: input.failedCategories,
+            });
+            return result;
+        }
+        const request = (0, prompts_1.buildCoverageSummaryPrompt)(input);
+        request.events = [...this.eventStream.getEvents()];
+        const raw = await this.client.send('coverageSummary', request);
+        const normalized = (0, normalizer_1.normalizeMcpResponse)(raw, 'coverage');
+        if (!raw.ok)
+            normalized.isFallback = true;
+        return normalized;
+    }
+    /** Analyze security scan results via MCP (or fallback if unavailable) */
+    async analyzeSecurity(input) {
+        if (!(0, config_1.isMcpEnabledFor)(this.config, 'securityScan')) {
+            return (0, fallback_1.generateFallbackSecurityAnalysis)({ scanSummary: input.scanSummary });
+        }
+        const request = (0, prompts_1.buildSecurityScanPrompt)(input);
+        request.events = [...this.eventStream.getEvents()];
+        const raw = await this.client.send('securityScan', request);
+        const normalized = (0, normalizer_1.normalizeMcpResponse)(raw, 'security');
+        if (!raw.ok)
+            normalized.isFallback = true;
+        return normalized;
+    }
+    /** Analyze performance / resilience coverage via MCP (or fallback) */
+    async analyzePerformance(input) {
+        if (!(0, config_1.isMcpEnabledFor)(this.config, 'performanceAnalysis')) {
+            return (0, fallback_1.generateFallbackAnalysis)('performance', input.coveragePercent, undefined);
+        }
+        const request = (0, prompts_1.buildPerformancePrompt)(input);
+        const raw = await this.client.send('performanceAnalysis', request);
+        const normalized = (0, normalizer_1.normalizeMcpResponse)(raw, 'performance');
+        if (!raw.ok)
+            normalized.isFallback = true;
+        return normalized;
+    }
+    /** Analyze compatibility / contract coverage via MCP (or fallback) */
+    async analyzeCompatibility(input) {
+        if (!(0, config_1.isMcpEnabledFor)(this.config, 'compatibilityAnalysis')) {
+            return (0, fallback_1.generateFallbackAnalysis)('compatibility', input.compatibilityPercent, undefined);
+        }
+        const request = (0, prompts_1.buildCompatibilityPrompt)(input);
+        const raw = await this.client.send('compatibilityAnalysis', request);
+        const normalized = (0, normalizer_1.normalizeMcpResponse)(raw, 'compatibility');
+        if (!raw.ok)
+            normalized.isFallback = true;
+        return normalized;
+    }
+    /** Generate a CI/PR summary via MCP (or fallback) */
+    async analyzeCiSummary(input) {
+        if (!(0, config_1.isMcpEnabledFor)(this.config, 'coverageSummary')) {
+            const gatePassed = input.overallPassed;
+            return (0, fallback_1.generateFallbackCoverageAnalysis)({
+                results: input.coverageResults,
+                gatePassed,
+                failedCategories: input.failedGates,
+            });
+        }
+        const request = (0, prompts_1.buildCiSummaryPrompt)(input);
+        const raw = await this.client.send('coverageSummary', request);
+        const normalized = (0, normalizer_1.normalizeMcpResponse)(raw, 'ci-summary');
+        if (!raw.ok)
+            normalized.isFallback = true;
+        return normalized;
+    }
+    /** Analyze coverage intelligence results via MCP (or fallback if unavailable) */
+    async analyzeIntelligence(input) {
+        if (!(0, config_1.isMcpEnabledFor)(this.config, 'intelligenceAnalysis')) {
+            return (0, fallback_1.generateFallbackIntelligenceAnalysis)({
+                totalFindings: input.totalFindings,
+                totalRecommendations: input.totalRecommendations,
+                maxRiskScore: input.maxRiskScore,
+                avgRiskScore: input.avgRiskScore,
+                criticalUncoveredItems: input.criticalUncoveredItems,
+                unprotectedSecurityFindings: input.unprotectedSecurityFindings,
+                recommendationsByPriority: input.recommendationsByPriority,
+                languages: input.languages,
+                frameworks: input.frameworks,
+            });
+        }
+        const request = (0, prompts_1.buildIntelligencePrompt)(input);
+        request.events = [...this.eventStream.getEvents()];
+        const raw = await this.client.send('intelligenceAnalysis', request);
+        const normalized = (0, normalizer_1.normalizeMcpResponse)(raw, 'intelligence');
+        if (!raw.ok)
+            normalized.isFallback = true;
+        return normalized;
+    }
+    // ─── Rendering helpers ──────────────────────────────────────────────────────
+    /** Render a NormalizedAiAnalysis as Markdown */
+    renderMarkdown(analysis, category, categoryTitle) {
+        return (0, templates_1.renderAiAnalysisMarkdown)({
+            analysis,
+            category,
+            categoryTitle,
+            mcpEnabled: this.config.enabled,
+        });
+    }
+    /** Render a NormalizedAiAnalysis as HTML */
+    renderHtml(analysis, category, categoryTitle) {
+        return (0, templates_1.renderAiAnalysisHtml)({
+            analysis,
+            category,
+            categoryTitle,
+            mcpEnabled: this.config.enabled,
+        });
+    }
+    /** Build dashboard panel data from a NormalizedAiAnalysis */
+    buildPanelData(analysis) {
+        return (0, templates_1.buildAiPanelData)(analysis);
+    }
+    // ─── Accessors ──────────────────────────────────────────────────────────────
+    /** Whether MCP is globally enabled */
+    isEnabled() {
+        return this.config.enabled === true;
+    }
+    /** Whether MCP is enabled for a specific server/category */
+    isEnabledFor(serverName) {
+        return (0, config_1.isMcpEnabledFor)(this.config, serverName);
+    }
+    /** Collect all buffered events */
+    getEvents() {
+        return this.eventStream.getEvents();
+    }
+}
+exports.McpIntegration = McpIntegration;

package/dist/src/mcp/normalizer.d.ts

@@ -0,0 +1,21 @@
+/**
+ * MCP integration – response normalizer.
+ *
+ * Converts raw MCP server responses into the deterministic NormalizedAiAnalysis
+ * schema.  The analyzer NEVER renders raw MCP output directly.
+ *
+ * Handles:
+ *  - Well-formed JSON responses
+ *  - Partial/malformed JSON (graceful degradation)
+ *  - Non-JSON plain text
+ *  - Empty / error responses
+ */
+import type { McpRawResponse, NormalizedAiAnalysis } from './types';
+/**
+ * Normalize a raw MCP response into a NormalizedAiAnalysis object.
+ *
+ * When the response cannot be parsed the function returns a best-effort object
+ * rather than throwing, so callers can always render something useful.
+ */
+export declare function normalizeMcpResponse(raw: McpRawResponse, category: string): NormalizedAiAnalysis;
+//# sourceMappingURL=normalizer.d.ts.map

package/dist/src/mcp/normalizer.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"normalizer.d.ts","sourceRoot":"","sources":["../../../src/mcp/normalizer.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;GAWG;AAEH,OAAO,KAAK,EAAE,cAAc,EAAE,oBAAoB,EAAgB,MAAM,SAAS,CAAC;AAIlF;;;;;GAKG;AACH,wBAAgB,oBAAoB,CAClC,GAAG,EAAE,cAAc,EACnB,QAAQ,EAAE,MAAM,GACf,oBAAoB,CAmBtB"}

package/dist/src/mcp/normalizer.js

@@ -0,0 +1,99 @@
+"use strict";
+/**
+ * MCP integration – response normalizer.
+ *
+ * Converts raw MCP server responses into the deterministic NormalizedAiAnalysis
+ * schema.  The analyzer NEVER renders raw MCP output directly.
+ *
+ * Handles:
+ *  - Well-formed JSON responses
+ *  - Partial/malformed JSON (graceful degradation)
+ *  - Non-JSON plain text
+ *  - Empty / error responses
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.normalizeMcpResponse = normalizeMcpResponse;
+// ─── Main normalizer ──────────────────────────────────────────────────────────
+/**
+ * Normalize a raw MCP response into a NormalizedAiAnalysis object.
+ *
+ * When the response cannot be parsed the function returns a best-effort object
+ * rather than throwing, so callers can always render something useful.
+ */
+function normalizeMcpResponse(raw, category) {
+    var _a;
+    if (!raw.ok || !raw.content) {
+        return errorFallback(category, (_a = raw.error) !== null && _a !== void 0 ? _a : 'MCP server returned no content');
+    }
+    const parsed = tryParseJson(raw.content.trim());
+    if (parsed !== null && typeof parsed === 'object' && !Array.isArray(parsed)) {
+        return normalizeObject(parsed, category);
+    }
+    // Plain-text response – wrap into a minimal schema
+    return {
+        summary: raw.content.slice(0, 500),
+        keyFindings: [],
+        topRisks: [],
+        recommendedActions: [],
+        confidence: 'low',
+        category,
+    };
+}
+// ─── Internal helpers ─────────────────────────────────────────────────────────
+function normalizeObject(obj, category) {
+    var _a, _b, _c, _d, _e, _f;
+    return {
+        summary: asString(obj['summary'], 'No summary provided.'),
+        keyFindings: asStringArray((_a = obj['keyFindings']) !== null && _a !== void 0 ? _a : obj['key_findings']),
+        topRisks: asStringArray((_b = obj['topRisks']) !== null && _b !== void 0 ? _b : obj['top_risks']),
+        recommendedActions: asStringArray((_d = (_c = obj['recommendedActions']) !== null && _c !== void 0 ? _c : obj['recommended_actions']) !== null && _d !== void 0 ? _d : obj['actions']),
+        missingCoverageAreas: asStringArray((_e = obj['missingCoverageAreas']) !== null && _e !== void 0 ? _e : obj['missing_coverage_areas'], true),
+        likelyRootCauses: asStringArray((_f = obj['likelyRootCauses']) !== null && _f !== void 0 ? _f : obj['likely_root_causes'], true),
+        confidence: asConfidence(obj['confidence']),
+        category,
+    };
+}
+function errorFallback(category, errorMsg) {
+    return {
+        summary: `MCP analysis unavailable: ${errorMsg}`,
+        keyFindings: [],
+        topRisks: [],
+        recommendedActions: [],
+        confidence: 'low',
+        category,
+    };
+}
+function tryParseJson(text) {
+    // Strip markdown code fences if present
+    const fenced = text.match(/```(?:json)?\s*([\s\S]*?)```/);
+    const source = fenced ? fenced[1].trim() : text;
+    // Find the first JSON object or array in the text
+    const jsonStart = source.search(/[{[]/);
+    if (jsonStart === -1)
+        return null;
+    try {
+        return JSON.parse(source.slice(jsonStart));
+    }
+    catch {
+        return null;
+    }
+}
+function asString(val, fallback) {
+    if (typeof val === 'string' && val.length > 0)
+        return val;
+    return fallback;
+}
+function asStringArray(val, allowUndefined) {
+    if (allowUndefined && (val === undefined || val === null))
+        return [];
+    if (!Array.isArray(val))
+        return [];
+    return val
+        .filter((v) => typeof v === 'string' && v.length > 0)
+        .map((v) => v);
+}
+function asConfidence(val) {
+    if (val === 'low' || val === 'medium' || val === 'high')
+        return val;
+    return 'medium';
+}