api-tests-coverage 1.0.0

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

@@ -0,0 +1,235 @@
+"use strict";
+/**
+ * MCP integration – client.
+ *
+ * Manages transport connections, sends prompts, and returns raw MCP responses.
+ * Supports stdio (child-process) and HTTP transports.
+ *
+ * Security:
+ *  - Server URLs validated against allowlist before connection.
+ *  - Transports validated against allowlist.
+ *  - Payload size validated before sending.
+ *  - Secrets redacted from all outgoing payloads.
+ *  - Hard timeout enforced per request.
+ */
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.McpClient = void 0;
+const http = __importStar(require("http"));
+const https = __importStar(require("https"));
+const childProcess = __importStar(require("child_process"));
+const url_1 = require("url");
+const config_1 = require("../config");
+// ─── MCP Client ───────────────────────────────────────────────────────────────
+class McpClient {
+    /**
+     * @param globalConfig  MCP configuration block
+     * @param spawnFn       Optional spawn override (useful in unit tests to avoid
+     *                      spawning real child processes)
+     */
+    constructor(globalConfig, spawnFn) {
+        this.globalConfig = globalConfig;
+        this.spawnFn = spawnFn !== null && spawnFn !== void 0 ? spawnFn : childProcess.spawn;
+    }
+    /**
+     * Send a prompt to the named MCP server and return the raw response.
+     *
+     * @param serverName  Key in config.servers (e.g. "coverageSummary")
+     * @param request     Prompt request to send
+     */
+    async send(serverName, request) {
+        var _a, _b, _c, _d, _e, _f, _g, _h, _j;
+        const serverCfg = (0, config_1.resolveServerConfig)(this.globalConfig, serverName);
+        const transport = (_a = serverCfg.transport) !== null && _a !== void 0 ? _a : 'stdio';
+        // Security: validate transport and server URL
+        (0, config_1.validateTransport)(this.globalConfig, transport);
+        if (transport === 'http' && serverCfg.url) {
+            (0, config_1.validateServerUrl)(this.globalConfig, serverCfg.url);
+        }
+        // Security: redact secrets from context before serialising
+        const sanitisedRequest = {
+            ...request,
+            context: (0, config_1.redactSecrets)(request.context),
+        };
+        const payload = JSON.stringify(sanitisedRequest);
+        (0, config_1.validatePayloadSize)(this.globalConfig, payload);
+        const maxRetries = (_c = (_b = this.globalConfig.retryPolicy) === null || _b === void 0 ? void 0 : _b.maxRetries) !== null && _c !== void 0 ? _c : config_1.MCP_DEFAULT_MAX_RETRIES;
+        const retryDelayMs = (_e = (_d = this.globalConfig.retryPolicy) === null || _d === void 0 ? void 0 : _d.retryDelayMs) !== null && _e !== void 0 ? _e : config_1.MCP_DEFAULT_RETRY_DELAY_MS;
+        const timeoutMs = (_f = serverCfg.timeoutMs) !== null && _f !== void 0 ? _f : config_1.MCP_DEFAULT_TIMEOUT_MS;
+        let lastError;
+        for (let attempt = 0; attempt <= maxRetries; attempt++) {
+            if (attempt > 0) {
+                await sleep(retryDelayMs);
+            }
+            try {
+                if (transport === 'http') {
+                    return await this.sendHttp(serverCfg.url, payload, timeoutMs);
+                }
+                else {
+                    return await this.sendStdio((_g = serverCfg.command) !== null && _g !== void 0 ? _g : 'node', (_h = serverCfg.args) !== null && _h !== void 0 ? _h : [], payload, timeoutMs);
+                }
+            }
+            catch (err) {
+                lastError = err instanceof Error ? err : new Error(String(err));
+            }
+        }
+        return { ok: false, error: (_j = lastError === null || lastError === void 0 ? void 0 : lastError.message) !== null && _j !== void 0 ? _j : 'Unknown MCP error' };
+    }
+    // ─── HTTP transport ─────────────────────────────────────────────────────────
+    sendHttp(url, payload, timeoutMs) {
+        return new Promise((resolve) => {
+            var _a;
+            const start = Date.now();
+            let resolved = false;
+            const timer = setTimeout(() => {
+                if (!resolved) {
+                    resolved = true;
+                    resolve({ ok: false, error: 'MCP HTTP request timed out', latencyMs: timeoutMs });
+                }
+            }, timeoutMs);
+            try {
+                const parsedUrl = new url_1.URL(url);
+                const isHttps = parsedUrl.protocol === 'https:';
+                const lib = isHttps ? https : http;
+                const options = {
+                    hostname: parsedUrl.hostname,
+                    port: parsedUrl.port || (isHttps ? 443 : 80),
+                    path: parsedUrl.pathname + ((_a = parsedUrl.search) !== null && _a !== void 0 ? _a : ''),
+                    method: 'POST',
+                    headers: {
+                        'Content-Type': 'application/json',
+                        'Content-Length': Buffer.byteLength(payload),
+                    },
+                    timeout: timeoutMs,
+                };
+                const req = lib.request(options, (res) => {
+                    const chunks = [];
+                    res.on('data', (chunk) => chunks.push(chunk));
+                    res.on('end', () => {
+                        var _a, _b;
+                        clearTimeout(timer);
+                        if (!resolved) {
+                            resolved = true;
+                            const body = Buffer.concat(chunks).toString('utf-8');
+                            const latencyMs = Date.now() - start;
+                            if (((_a = res.statusCode) !== null && _a !== void 0 ? _a : 0) >= 200 && ((_b = res.statusCode) !== null && _b !== void 0 ? _b : 0) < 300) {
+                                resolve({ ok: true, content: body, latencyMs });
+                            }
+                            else {
+                                resolve({
+                                    ok: false,
+                                    error: `HTTP ${res.statusCode}: ${body.slice(0, 200)}`,
+                                    latencyMs,
+                                });
+                            }
+                        }
+                    });
+                });
+                req.on('error', (err) => {
+                    clearTimeout(timer);
+                    if (!resolved) {
+                        resolved = true;
+                        resolve({ ok: false, error: err.message, latencyMs: Date.now() - start });
+                    }
+                });
+                req.write(payload);
+                req.end();
+            }
+            catch (err) {
+                clearTimeout(timer);
+                if (!resolved) {
+                    resolved = true;
+                    resolve({
+                        ok: false,
+                        error: err instanceof Error ? err.message : String(err),
+                        latencyMs: Date.now() - start,
+                    });
+                }
+            }
+        });
+    }
+    // ─── stdio transport ────────────────────────────────────────────────────────
+    sendStdio(command, args, payload, timeoutMs) {
+        return new Promise((resolve) => {
+            const start = Date.now();
+            let resolved = false;
+            const timer = setTimeout(() => {
+                if (!resolved) {
+                    resolved = true;
+                    child.kill();
+                    resolve({ ok: false, error: 'MCP stdio process timed out', latencyMs: timeoutMs });
+                }
+            }, timeoutMs);
+            const child = this.spawnFn(command, args, { stdio: ['pipe', 'pipe', 'pipe'] });
+            const chunks = [];
+            const errChunks = [];
+            child.stdout.on('data', (chunk) => chunks.push(chunk));
+            child.stderr.on('data', (chunk) => errChunks.push(chunk));
+            child.on('close', (code) => {
+                clearTimeout(timer);
+                if (!resolved) {
+                    resolved = true;
+                    const latencyMs = Date.now() - start;
+                    if (code === 0) {
+                        const content = Buffer.concat(chunks).toString('utf-8');
+                        resolve({ ok: true, content, latencyMs });
+                    }
+                    else {
+                        const stderr = Buffer.concat(errChunks).toString('utf-8');
+                        resolve({
+                            ok: false,
+                            error: `MCP stdio process exited with code ${code}: ${stderr.slice(0, 200)}`,
+                            latencyMs,
+                        });
+                    }
+                }
+            });
+            child.on('error', (err) => {
+                clearTimeout(timer);
+                if (!resolved) {
+                    resolved = true;
+                    resolve({ ok: false, error: err.message, latencyMs: Date.now() - start });
+                }
+            });
+            child.stdin.write(payload + '\n');
+            child.stdin.end();
+        });
+    }
+}
+exports.McpClient = McpClient;
+// ─── Helpers ──────────────────────────────────────────────────────────────────
+function sleep(ms) {
+    return new Promise((resolve) => setTimeout(resolve, ms));
+}

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

@@ -0,0 +1,50 @@
+/**
+ * MCP integration – configuration loader and validator.
+ *
+ * Handles loading the `mcp` block from the project config file, applying
+ * defaults, validating allowed transports and server URLs, and providing a
+ * single function to resolve the effective configuration for a named server.
+ */
+import type { McpConfig, McpServerConfig, McpTransport } from './types';
+export declare const MCP_DEFAULT_TIMEOUT_MS = 30000;
+export declare const MCP_DEFAULT_MAX_PAYLOAD_BYTES = 1048576;
+export declare const MCP_DEFAULT_MAX_RETRIES = 2;
+export declare const MCP_DEFAULT_RETRY_DELAY_MS = 500;
+export declare const MCP_DEFAULT_TRANSPORT: McpTransport;
+export declare const MCP_ALLOWED_TRANSPORTS: McpTransport[];
+/** Sensitive key patterns that must never appear in MCP prompts */
+export declare const REDACTED_KEYS: string[];
+/**
+ * Merge per-server overrides with global defaults.
+ */
+export declare function resolveServerConfig(global: McpConfig, serverName: string): McpServerConfig & {
+    timeoutMs: number;
+};
+/**
+ * Return true if MCP is globally enabled AND the named server is enabled.
+ */
+export declare function isMcpEnabledFor(config: McpConfig, serverName: string): boolean;
+/**
+ * Validate that the transport is in the allowlist (if configured).
+ * Throws when the transport is not permitted.
+ */
+export declare function validateTransport(config: McpConfig, transport: McpTransport): void;
+/**
+ * Validate that an HTTP server URL is in the allowlist (if configured).
+ * Throws when the URL does not match any allowed prefix.
+ */
+export declare function validateServerUrl(config: McpConfig, url: string): void;
+/**
+ * Validate that a payload string does not exceed the configured size limit.
+ * Throws when the limit is exceeded.
+ */
+export declare function validatePayloadSize(config: McpConfig, payload: string): void;
+/**
+ * Recursively redact sensitive values from a plain object.
+ * Keys matching any of the REDACTED_KEYS patterns (case-insensitive) have
+ * their values replaced with "[REDACTED]".
+ *
+ * Returns a deep-cloned sanitised copy; never mutates the original.
+ */
+export declare function redactSecrets(obj: unknown): unknown;
+//# sourceMappingURL=config.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"config.d.ts","sourceRoot":"","sources":["../../../src/mcp/config.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AAEH,OAAO,KAAK,EACV,SAAS,EACT,eAAe,EACf,YAAY,EACb,MAAM,SAAS,CAAC;AAIjB,eAAO,MAAM,sBAAsB,QAAS,CAAC;AAC7C,eAAO,MAAM,6BAA6B,UAAY,CAAC;AACvD,eAAO,MAAM,uBAAuB,IAAI,CAAC;AACzC,eAAO,MAAM,0BAA0B,MAAM,CAAC;AAC9C,eAAO,MAAM,qBAAqB,EAAE,YAAsB,CAAC;AAE3D,eAAO,MAAM,sBAAsB,EAAE,YAAY,EAAsB,CAAC;AAExE,mEAAmE;AACnE,eAAO,MAAM,aAAa,UAczB,CAAC;AAIF;;GAEG;AACH,wBAAgB,mBAAmB,CACjC,MAAM,EAAE,SAAS,EACjB,UAAU,EAAE,MAAM,GACjB,eAAe,GAAG;IAAE,SAAS,EAAE,MAAM,CAAA;CAAE,CAOzC;AAED;;GAEG;AACH,wBAAgB,eAAe,CAAC,MAAM,EAAE,SAAS,EAAE,UAAU,EAAE,MAAM,GAAG,OAAO,CAK9E;AAID;;;GAGG;AACH,wBAAgB,iBAAiB,CAAC,MAAM,EAAE,SAAS,EAAE,SAAS,EAAE,YAAY,GAAG,IAAI,CAQlF;AAED;;;GAGG;AACH,wBAAgB,iBAAiB,CAAC,MAAM,EAAE,SAAS,EAAE,GAAG,EAAE,MAAM,GAAG,IAAI,CAStE;AAID;;;GAGG;AACH,wBAAgB,mBAAmB,CAAC,MAAM,EAAE,SAAS,EAAE,OAAO,EAAE,MAAM,GAAG,IAAI,CAQ5E;AAID;;;;;;GAMG;AACH,wBAAgB,aAAa,CAAC,GAAG,EAAE,OAAO,GAAG,OAAO,CAYnD"}

package/dist/src/mcp/config.js

@@ -0,0 +1,125 @@
+"use strict";
+/**
+ * MCP integration – configuration loader and validator.
+ *
+ * Handles loading the `mcp` block from the project config file, applying
+ * defaults, validating allowed transports and server URLs, and providing a
+ * single function to resolve the effective configuration for a named server.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.REDACTED_KEYS = exports.MCP_ALLOWED_TRANSPORTS = exports.MCP_DEFAULT_TRANSPORT = exports.MCP_DEFAULT_RETRY_DELAY_MS = exports.MCP_DEFAULT_MAX_RETRIES = exports.MCP_DEFAULT_MAX_PAYLOAD_BYTES = exports.MCP_DEFAULT_TIMEOUT_MS = void 0;
+exports.resolveServerConfig = resolveServerConfig;
+exports.isMcpEnabledFor = isMcpEnabledFor;
+exports.validateTransport = validateTransport;
+exports.validateServerUrl = validateServerUrl;
+exports.validatePayloadSize = validatePayloadSize;
+exports.redactSecrets = redactSecrets;
+// ─── Defaults ─────────────────────────────────────────────────────────────────
+exports.MCP_DEFAULT_TIMEOUT_MS = 30000;
+exports.MCP_DEFAULT_MAX_PAYLOAD_BYTES = 1048576; // 1 MB
+exports.MCP_DEFAULT_MAX_RETRIES = 2;
+exports.MCP_DEFAULT_RETRY_DELAY_MS = 500;
+exports.MCP_DEFAULT_TRANSPORT = 'stdio';
+exports.MCP_ALLOWED_TRANSPORTS = ['stdio', 'http'];
+/** Sensitive key patterns that must never appear in MCP prompts */
+exports.REDACTED_KEYS = [
+    'token',
+    'password',
+    'secret',
+    'apikey',
+    'api_key',
+    'connectionstring',
+    'connection_string',
+    'authorization',
+    'bearer',
+    'private_key',
+    'privatekey',
+    'access_key',
+    'accesskey',
+];
+// ─── Effective config resolution ──────────────────────────────────────────────
+/**
+ * Merge per-server overrides with global defaults.
+ */
+function resolveServerConfig(global, serverName) {
+    var _a, _b, _c, _d, _e, _f;
+    const server = (_b = (_a = global.servers) === null || _a === void 0 ? void 0 : _a[serverName]) !== null && _b !== void 0 ? _b : {};
+    return {
+        ...server,
+        transport: (_d = (_c = server.transport) !== null && _c !== void 0 ? _c : global.defaultTransport) !== null && _d !== void 0 ? _d : exports.MCP_DEFAULT_TRANSPORT,
+        timeoutMs: (_f = (_e = server.timeoutMs) !== null && _e !== void 0 ? _e : global.timeoutMs) !== null && _f !== void 0 ? _f : exports.MCP_DEFAULT_TIMEOUT_MS,
+    };
+}
+/**
+ * Return true if MCP is globally enabled AND the named server is enabled.
+ */
+function isMcpEnabledFor(config, serverName) {
+    var _a;
+    if (!config.enabled)
+        return false;
+    const server = (_a = config.servers) === null || _a === void 0 ? void 0 : _a[serverName];
+    // If the server key is omitted entirely it defaults to disabled.
+    return (server === null || server === void 0 ? void 0 : server.enabled) === true;
+}
+// ─── Transport validation ─────────────────────────────────────────────────────
+/**
+ * Validate that the transport is in the allowlist (if configured).
+ * Throws when the transport is not permitted.
+ */
+function validateTransport(config, transport) {
+    const allowlist = config.transportAllowlist;
+    if (!allowlist || allowlist.length === 0)
+        return;
+    if (!allowlist.includes(transport)) {
+        throw new Error(`MCP transport "${transport}" is not in the configured allowlist [${allowlist.join(', ')}]`);
+    }
+}
+/**
+ * Validate that an HTTP server URL is in the allowlist (if configured).
+ * Throws when the URL does not match any allowed prefix.
+ */
+function validateServerUrl(config, url) {
+    const allowlist = config.serverAllowlist;
+    if (!allowlist || allowlist.length === 0)
+        return;
+    const permitted = allowlist.some((prefix) => url.startsWith(prefix));
+    if (!permitted) {
+        throw new Error(`MCP server URL "${url}" is not in the configured server allowlist`);
+    }
+}
+// ─── Payload size validation ──────────────────────────────────────────────────
+/**
+ * Validate that a payload string does not exceed the configured size limit.
+ * Throws when the limit is exceeded.
+ */
+function validatePayloadSize(config, payload) {
+    var _a;
+    const limitBytes = (_a = config.maxPayloadBytes) !== null && _a !== void 0 ? _a : exports.MCP_DEFAULT_MAX_PAYLOAD_BYTES;
+    const sizeBytes = Buffer.byteLength(payload, 'utf-8');
+    if (sizeBytes > limitBytes) {
+        throw new Error(`MCP prompt payload size ${sizeBytes} B exceeds the configured limit of ${limitBytes} B`);
+    }
+}
+// ─── Secret redaction ─────────────────────────────────────────────────────────
+/**
+ * Recursively redact sensitive values from a plain object.
+ * Keys matching any of the REDACTED_KEYS patterns (case-insensitive) have
+ * their values replaced with "[REDACTED]".
+ *
+ * Returns a deep-cloned sanitised copy; never mutates the original.
+ */
+function redactSecrets(obj) {
+    if (obj === null || obj === undefined)
+        return obj;
+    if (typeof obj !== 'object')
+        return obj;
+    if (Array.isArray(obj))
+        return obj.map(redactSecrets);
+    const out = {};
+    for (const [key, val] of Object.entries(obj)) {
+        const lowerKey = key.toLowerCase().replace(/[^a-z0-9]/g, '');
+        const isSensitive = exports.REDACTED_KEYS.some((k) => lowerKey.includes(k.replace(/[^a-z0-9]/g, '')));
+        out[key] = isSensitive ? '[REDACTED]' : redactSecrets(val);
+    }
+    return out;
+}

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

@@ -0,0 +1,24 @@
+/**
+ * MCP integration – real-time scan event adapter.
+ *
+ * Provides a lightweight event bus that emits AnalysisEvent objects during a
+ * scan run.  When MCP real-time mode is enabled the events are buffered and
+ * forwarded to the configured MCP server; when disabled they are buffered for
+ * inclusion in the final report prompt only.
+ */
+import type { AnalysisEvent, AnalysisEventType } from './types';
+export declare class AnalysisEventStream {
+    private readonly _events;
+    private readonly _handlers;
+    /** Emit an event onto the stream */
+    emit(type: AnalysisEventType, payload?: Record<string, unknown>): void;
+    /** Subscribe to all events emitted on this stream */
+    subscribe(handler: (event: AnalysisEvent) => void): void;
+    /** Return a snapshot of all events emitted so far */
+    getEvents(): ReadonlyArray<AnalysisEvent>;
+    /** Clear buffered events (useful between scan phases) */
+    clear(): void;
+}
+/** Create a pre-wired event stream that does nothing (no-op) when MCP is off */
+export declare function createNoOpStream(): AnalysisEventStream;
+//# sourceMappingURL=events.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"events.d.ts","sourceRoot":"","sources":["../../../src/mcp/events.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AAEH,OAAO,KAAK,EAAE,aAAa,EAAE,iBAAiB,EAAE,MAAM,SAAS,CAAC;AAIhE,qBAAa,mBAAmB;IAC9B,OAAO,CAAC,QAAQ,CAAC,OAAO,CAAuB;IAC/C,OAAO,CAAC,QAAQ,CAAC,SAAS,CAA6C;IAEvE,oCAAoC;IACpC,IAAI,CAAC,IAAI,EAAE,iBAAiB,EAAE,OAAO,GAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAM,GAAG,IAAI;IAQ1E,qDAAqD;IACrD,SAAS,CAAC,OAAO,EAAE,CAAC,KAAK,EAAE,aAAa,KAAK,IAAI,GAAG,IAAI;IAIxD,qDAAqD;IACrD,SAAS,IAAI,aAAa,CAAC,aAAa,CAAC;IAIzC,yDAAyD;IACzD,KAAK,IAAI,IAAI;CAGd;AAID,gFAAgF;AAChF,wBAAgB,gBAAgB,IAAI,mBAAmB,CAEtD"}

package/dist/src/mcp/events.js

@@ -0,0 +1,48 @@
+"use strict";
+/**
+ * MCP integration – real-time scan event adapter.
+ *
+ * Provides a lightweight event bus that emits AnalysisEvent objects during a
+ * scan run.  When MCP real-time mode is enabled the events are buffered and
+ * forwarded to the configured MCP server; when disabled they are buffered for
+ * inclusion in the final report prompt only.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AnalysisEventStream = void 0;
+exports.createNoOpStream = createNoOpStream;
+// ─── Event emitter ────────────────────────────────────────────────────────────
+class AnalysisEventStream {
+    constructor() {
+        this._events = [];
+        this._handlers = [];
+    }
+    /** Emit an event onto the stream */
+    emit(type, payload = {}) {
+        const event = { type, timestamp: Date.now(), payload };
+        this._events.push(event);
+        for (const handler of this._handlers) {
+            try {
+                handler(event);
+            }
+            catch { /* never let handlers crash the scan */ }
+        }
+    }
+    /** Subscribe to all events emitted on this stream */
+    subscribe(handler) {
+        this._handlers.push(handler);
+    }
+    /** Return a snapshot of all events emitted so far */
+    getEvents() {
+        return [...this._events];
+    }
+    /** Clear buffered events (useful between scan phases) */
+    clear() {
+        this._events.length = 0;
+    }
+}
+exports.AnalysisEventStream = AnalysisEventStream;
+// ─── Convenience helpers ──────────────────────────────────────────────────────
+/** Create a pre-wired event stream that does nothing (no-op) when MCP is off */
+function createNoOpStream() {
+    return new AnalysisEventStream();
+}

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

@@ -0,0 +1,50 @@
+/**
+ * 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.
+ */
+import type { NormalizedAiAnalysis } from '../types';
+import type { CoverageResult } from '../../reporting';
+import type { SecurityScanSummary } from '../../security/types';
+export interface FallbackCoverageInput {
+    results: CoverageResult[];
+    thresholds?: Record<string, number | undefined>;
+    gatePassed?: boolean;
+    failedCategories?: string[];
+}
+/**
+ * Generate a deterministic AI-style coverage summary without MCP.
+ */
+export declare function generateFallbackCoverageAnalysis(input: FallbackCoverageInput): NormalizedAiAnalysis;
+export interface FallbackSecurityInput {
+    scanSummary: SecurityScanSummary;
+}
+/**
+ * Generate a deterministic AI-style security analysis without MCP.
+ */
+export declare function generateFallbackSecurityAnalysis(input: FallbackSecurityInput): NormalizedAiAnalysis;
+export interface FallbackIntelligenceInput {
+    totalFindings: number;
+    totalRecommendations: number;
+    maxRiskScore: number;
+    avgRiskScore: number;
+    criticalUncoveredItems: number;
+    unprotectedSecurityFindings: number;
+    recommendationsByPriority: Record<string, number>;
+    topRiskAreas?: string[];
+    languages?: string[];
+    frameworks?: string[];
+}
+/**
+ * Generate a deterministic AI-style intelligence analysis without MCP.
+ */
+export declare function generateFallbackIntelligenceAnalysis(input: FallbackIntelligenceInput): NormalizedAiAnalysis;
+/**
+ * Generate a minimal deterministic AI analysis for any coverage category.
+ */
+export declare function generateFallbackAnalysis(category: string, coveragePercent: number, threshold?: number): NormalizedAiAnalysis;
+//# sourceMappingURL=index.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../src/mcp/fallback/index.ts"],"names":[],"mappings":"AAAA;;;;;;;;GAQG;AAEH,OAAO,KAAK,EAAE,oBAAoB,EAAE,MAAM,UAAU,CAAC;AACrD,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,iBAAiB,CAAC;AACtD,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,sBAAsB,CAAC;AAIhE,MAAM,WAAW,qBAAqB;IACpC,OAAO,EAAE,cAAc,EAAE,CAAC;IAC1B,UAAU,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,GAAG,SAAS,CAAC,CAAC;IAChD,UAAU,CAAC,EAAE,OAAO,CAAC;IACrB,gBAAgB,CAAC,EAAE,MAAM,EAAE,CAAC;CAC7B;AAED;;GAEG;AACH,wBAAgB,gCAAgC,CAC9C,KAAK,EAAE,qBAAqB,GAC3B,oBAAoB,CAmDtB;AAID,MAAM,WAAW,qBAAqB;IACpC,WAAW,EAAE,mBAAmB,CAAC;CAClC;AAED;;GAEG;AACH,wBAAgB,gCAAgC,CAC9C,KAAK,EAAE,qBAAqB,GAC3B,oBAAoB,CA4DtB;AAID,MAAM,WAAW,yBAAyB;IACxC,aAAa,EAAE,MAAM,CAAC;IACtB,oBAAoB,EAAE,MAAM,CAAC;IAC7B,YAAY,EAAE,MAAM,CAAC;IACrB,YAAY,EAAE,MAAM,CAAC;IACrB,sBAAsB,EAAE,MAAM,CAAC;IAC/B,2BAA2B,EAAE,MAAM,CAAC;IACpC,yBAAyB,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;IAClD,YAAY,CAAC,EAAE,MAAM,EAAE,CAAC;IACxB,SAAS,CAAC,EAAE,MAAM,EAAE,CAAC;IACrB,UAAU,CAAC,EAAE,MAAM,EAAE,CAAC;CACvB;AAED;;GAEG;AACH,wBAAgB,oCAAoC,CAClD,KAAK,EAAE,yBAAyB,GAC/B,oBAAoB,CAkEtB;AAID;;GAEG;AACH,wBAAgB,wBAAwB,CACtC,QAAQ,EAAE,MAAM,EAChB,eAAe,EAAE,MAAM,EACvB,SAAS,CAAC,EAAE,MAAM,GACjB,oBAAoB,CAiBtB"}