api-tests-coverage 1.0.24 → 1.0.26

package/dist/src/analyzeHelpers.js

@@ -0,0 +1,670 @@
+"use strict";
+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.requiredNaReason = requiredNaReason;
+exports.buildNaCoverageResult = buildNaCoverageResult;
+exports.runMetricSafe = runMetricSafe;
+exports.enrichResultsWithStatuses = enrichResultsWithStatuses;
+exports.renderAnalyzeSummaryTable = renderAnalyzeSummaryTable;
+exports.detectOpenApiSpec = detectOpenApiSpec;
+exports.writeMetricReport = writeMetricReport;
+exports.writeArchitectureArtifacts = writeArchitectureArtifacts;
+exports.detailPathForMetric = detailPathForMetric;
+exports.metricTitle = metricTitle;
+exports.sortResultsInKnownOrder = sortResultsInKnownOrder;
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+const http = __importStar(require("http"));
+const https = __importStar(require("https"));
+const evaluateMetrics_1 = require("./summary/evaluateMetrics");
+const summaryTypes_1 = require("./summary/summaryTypes");
+const FILE_SPEC_CANDIDATES = [
+    'openapi.yaml',
+    'openapi.json',
+    path.join('docs', 'openapi.yaml'),
+    path.join('docs', 'openapi.json'),
+    path.join('src', 'main', 'resources', 'openapi.yaml'),
+    path.join('src', 'main', 'resources', 'openapi.json'),
+    path.join('src', 'main', 'resources', 'static', 'openapi.yaml'),
+    path.join('src', 'main', 'resources', 'static', 'openapi.json'),
+];
+const URL_SPEC_CANDIDATES = [
+    'http://localhost:8080/v3/api-docs',
+    'http://localhost:8080/swagger.json',
+];
+/**
+ * Returns the appropriate security N/A reason based on whether a spec was found.
+ * When a spec is present but yields no controls, the message should explain that
+ * the spec lacks security schemes/requirements rather than implying the spec is missing.
+ *
+ * @param context Optional reason-building context.
+ * @param context.specDetected Whether analyze already detected an OpenAPI spec.
+ * @returns A user-facing N/A reason string for the security metric.
+ */
+function securityNaReason({ specDetected = false }) {
+    if (specDetected) {
+        return 'No security schemes or requirements found in the OpenAPI spec.';
+    }
+    return 'No OpenAPI spec found. Add openapi.yaml to enable security control analysis.';
+}
+const REQUIRED_NA_REASONS = {
+    endpoint: ({ filesScanned = 0 }) => `No routes detected in ${filesScanned} source files. Ensure source files are in the scan root.`,
+    parameter: ({ routesScanned = 0 }) => `No parameters detected in ${routesScanned} routes. Add openapi.yaml for full parameter analysis.`,
+    business: ({ filesScanned = 0 }) => `No business rules detected in ${filesScanned} service files.`,
+    integration: ({ filesScanned = 0 }) => `No multi-step integration flows detected in ${filesScanned} test files.`,
+    error: () => 'No error scenarios detected. Add OpenAPI spec with 4xx/5xx responses.',
+    security: securityNaReason,
+    performance: ({ filesScanned = 0 }) => `No SLA annotations or load test results detected in ${filesScanned} scanned files.`,
+    resilience: ({ filesScanned = 0 }) => `No resilience patterns detected (circuit breakers, retries, timeouts) in ${filesScanned} files.`,
+    unit: ({ filesScanned = 0 }) => `No unit test cases detected in ${filesScanned} scanned test files.`,
+    event: ({ filesScanned = 0 }) => `No Kafka/RabbitMQ/SQS/SNS patterns detected in ${filesScanned} scanned source files.`,
+    compatibility: () => 'No previous API spec found. Provide --spec-old to enable compatibility checking.',
+};
+const METRIC_TITLES = {
+    endpoint: 'Endpoint Coverage',
+    parameter: 'Parameter Coverage',
+    business: 'Business Coverage',
+    integration: 'Integration Coverage',
+    error: 'Error Coverage',
+    security: 'Security Coverage',
+    performance: 'Performance Coverage',
+    resilience: 'Resilience Coverage',
+    compatibility: 'Compatibility Coverage',
+    event: 'Streaming Coverage',
+    unit: 'Unit Analysis',
+};
+const METRIC_REPORT_FILENAMES = {
+    endpoint: 'endpoint-coverage.json',
+    parameter: 'parameter-coverage.json',
+    business: 'business-coverage.json',
+    integration: 'integration-coverage.json',
+    error: 'error-coverage.json',
+    security: 'security-coverage.json',
+    performance: 'performance-coverage.json',
+    resilience: 'resilience-coverage.json',
+    compatibility: 'compatibility-coverage.json',
+    event: 'event-coverage.json',
+    unit: 'unit-coverage.json',
+};
+function requiredNaReason(type, context = {}) {
+    var _a, _b;
+    return (_b = (_a = REQUIRED_NA_REASONS[type]) === null || _a === void 0 ? void 0 : _a.call(REQUIRED_NA_REASONS, context)) !== null && _b !== void 0 ? _b : `No ${type} items detected during analysis.`;
+}
+function buildNaCoverageResult(type, reason, scanMeta, details = { items: [] }) {
+    return {
+        type,
+        totalItems: 0,
+        coveredItems: 0,
+        coveragePercent: 0,
+        status: 'N/A',
+        reason,
+        scanMeta,
+        details,
+    };
+}
+async function runMetricSafe(name, fallbackScanMeta, fn) {
+    var _a, _b;
+    try {
+        const result = await fn();
+        return {
+            ...result,
+            status: result.totalItems === 0 ? 'N/A' : result.status,
+            reason: result.totalItems === 0 ? ((_a = result.reason) !== null && _a !== void 0 ? _a : requiredNaReason(name)) : result.reason,
+            scanMeta: (_b = result.scanMeta) !== null && _b !== void 0 ? _b : fallbackScanMeta,
+        };
+    }
+    catch (err) {
+        const message = err instanceof Error ? err.message : String(err);
+        return buildNaCoverageResult(name, `Metric execution error: ${message}`, {
+            ...fallbackScanMeta,
+            detectionMethod: 'failed',
+        });
+    }
+}
+function enrichResultsWithStatuses(results, thresholds, qualityGate) {
+    const evaluated = (0, evaluateMetrics_1.evaluateMetrics)(results, thresholds, qualityGate);
+    const resultByType = new Map(results.map((result) => [result.type, result]));
+    return evaluated
+        .filter((metric) => resultByType.has(metric.category))
+        .map((metric) => {
+        var _a;
+        const result = resultByType.get(metric.category);
+        return {
+            ...result,
+            status: metric.status,
+            reason: (_a = result.reason) !== null && _a !== void 0 ? _a : metric.reason,
+        };
+    });
+}
+function renderAnalyzeSummaryTable(input) {
+    const evaluated = (0, evaluateMetrics_1.evaluateMetrics)(input.results, input.thresholds, input.qualityGate);
+    const lines = [
+        '=== API Test Coverage Analysis Complete ===',
+        `Project: ${input.rootDir}`,
+        `Scanned: ${input.serviceFiles} service files, ${input.testFiles} test files`,
+        `Duration: ${(input.durationMs / 1000).toFixed(1)}s`,
+        '',
+        '  Metric           Items   Covered      %     Status',
+        '  ─────────────────────────────────────────────────────────────────────────────',
+    ];
+    for (const metric of evaluated) {
+        const percentCell = metric.totalItems === 0 ? '-' : `${Math.round(metric.coveragePercent)}%`;
+        const statusCell = metric.status === 'PASS'
+            ? '✓ PASS'
+            : metric.status === 'FAIL'
+                ? '✗ FAIL'
+                : metric.status === 'SKIPPED'
+                    ? '· SKIPPED'
+                    : '· N/A';
+        const inlineReason = metric.status === 'N/A' ? `   ${metric.reason}` : '';
+        lines.push(`  ${metric.category.padEnd(13)} ${String(metric.totalItems).padStart(7)} ${String(metric.coveredItems).padStart(9)} ${percentCell.padStart(6)}     ${statusCell}${inlineReason}`);
+    }
+    return lines.join('\n');
+}
+async function detectOpenApiSpec(rootDir, reportsDir, explicitSpecPath) {
+    if (explicitSpecPath) {
+        const abs = path.resolve(explicitSpecPath);
+        if (fs.existsSync(abs))
+            return abs;
+    }
+    for (const candidate of FILE_SPEC_CANDIDATES) {
+        const abs = path.resolve(rootDir, candidate);
+        if (fs.existsSync(abs))
+            return abs;
+    }
+    for (const url of URL_SPEC_CANDIDATES) {
+        const content = await fetchUrlText(url);
+        if (!content)
+            continue;
+        fs.mkdirSync(reportsDir, { recursive: true });
+        const extension = url.endsWith('.json') || url.includes('api-docs') ? 'json' : 'yaml';
+        const targetPath = path.join(reportsDir, `auto-detected-openapi.${extension}`);
+        fs.writeFileSync(targetPath, content, 'utf-8');
+        return targetPath;
+    }
+    return undefined;
+}
+function writeMetricReport(result, reportsDir) {
+    const fileName = METRIC_REPORT_FILENAMES[result.type];
+    if (!fileName)
+        return;
+    const payload = buildMetricReportPayload(result);
+    const outPath = path.join(reportsDir, fileName);
+    fs.mkdirSync(reportsDir, { recursive: true });
+    fs.writeFileSync(outPath, JSON.stringify(payload, null, 2), 'utf-8');
+    if (result.type === 'unit') {
+        fs.writeFileSync(path.join(reportsDir, 'unit-analysis.json'), JSON.stringify(payload, null, 2), 'utf-8');
+    }
+}
+function writeArchitectureArtifacts(input) {
+    const generatedAt = new Date().toISOString();
+    const current = buildCurrentArchitecture({
+        generatedAt,
+        rootDir: input.rootDir,
+        languages: input.languages,
+        frameworks: input.frameworks,
+        serviceFiles: input.serviceFiles,
+        testFiles: input.testFiles,
+        hasSpec: Boolean(input.specPath),
+        results: input.results,
+    });
+    const suggested = buildSuggestedArchitecture({
+        generatedAt,
+        rootDir: input.rootDir,
+        results: input.results,
+    });
+    const markdown = buildArchitectureMarkdown(current, suggested, input.results);
+    const enriched = buildEnrichedArchitecturePayload(current, suggested, input.results);
+    fs.mkdirSync(input.reportsDir, { recursive: true });
+    fs.writeFileSync(path.join(input.reportsDir, 'architecture-current.json'), JSON.stringify({
+        ...current,
+        ...enriched,
+    }, null, 2), 'utf-8');
+    fs.writeFileSync(path.join(input.reportsDir, 'architecture-suggested.json'), JSON.stringify(suggested, null, 2), 'utf-8');
+    fs.writeFileSync(path.join(input.reportsDir, 'architecture.md'), markdown, 'utf-8');
+}
+function detailPathForMetric(type) {
+    switch (type) {
+        case 'endpoint':
+            return '/endpoints';
+        case 'parameter':
+            return '/parameters';
+        case 'business':
+            return '/business-rules';
+        case 'integration':
+            return '/integration-flows';
+        case 'error':
+            return '/error-handling';
+        case 'security':
+            return '/security';
+        case 'performance':
+        case 'resilience':
+            return '/performance';
+        case 'compatibility':
+            return '/compatibility';
+        case 'event':
+            return '/streaming';
+        case 'unit':
+            return '/unit';
+        default:
+            return '/';
+    }
+}
+function metricTitle(type) {
+    var _a;
+    return (_a = METRIC_TITLES[type]) !== null && _a !== void 0 ? _a : type;
+}
+function sortResultsInKnownOrder(results) {
+    const resultByType = new Map(results.map((result) => [result.type, result]));
+    const ordered = summaryTypes_1.KNOWN_METRIC_TYPES
+        .map((type) => resultByType.get(type))
+        .filter((result) => result !== undefined);
+    const extras = results.filter((result) => !summaryTypes_1.KNOWN_METRIC_TYPES.includes(result.type));
+    return [...ordered, ...extras];
+}
+function buildCurrentArchitecture(input) {
+    const nodes = [
+        {
+            id: 'project',
+            label: path.basename(input.rootDir) || 'project-root',
+            kind: 'artifact',
+            description: `Languages: ${input.languages.join(', ') || 'unknown'}; frameworks: ${input.frameworks.join(', ') || 'unknown'}`,
+        },
+        {
+            id: 'source',
+            label: `${input.serviceFiles} source files`,
+            kind: 'artifact',
+            description: 'Discovered service and implementation files',
+        },
+        {
+            id: 'tests',
+            label: `${input.testFiles} test files`,
+            kind: 'artifact',
+            description: 'Discovered unit, integration, and API tests',
+        },
+        {
+            id: 'spec',
+            label: input.hasSpec ? 'OpenAPI spec detected' : 'OpenAPI spec missing',
+            kind: 'artifact',
+        },
+        {
+            id: 'analyze',
+            label: 'analyze command',
+            kind: 'analysis',
+            description: 'Runs all metrics and writes reports/',
+        },
+        {
+            id: 'reports',
+            label: 'reports/',
+            kind: 'report',
+            description: 'Coverage, intelligence, summary, and architecture outputs',
+        },
+        ...buildMetricArchitectureNodes(input.results, 'current'),
+    ];
+    const edges = [
+        { from: 'project', to: 'source', label: 'discover' },
+        { from: 'project', to: 'tests', label: 'discover' },
+        { from: 'project', to: 'spec', label: 'detect' },
+        { from: 'source', to: 'analyze', label: 'scan' },
+        { from: 'tests', to: 'analyze', label: 'correlate' },
+        { from: 'spec', to: 'analyze', label: 'enrich' },
+        { from: 'analyze', to: 'reports', label: 'write' },
+        ...buildMetricArchitectureEdges(input.results, 'current'),
+    ];
+    return {
+        generatedAt: input.generatedAt,
+        projectRoot: input.rootDir,
+        nodes,
+        edges,
+    };
+}
+function buildSuggestedArchitecture(input) {
+    const prioritizedGaps = prioritizeArchitectureGaps(input.results);
+    const actionSteps = prioritizedGaps.map((gap, index) => `${index + 1}. ${gap.step}`);
+    const recommendations = prioritizedGaps.slice(0, 6).map((gap, index) => ({
+        id: `recommendation-${index + 1}`,
+        label: gap.label,
+        kind: 'recommendation',
+        description: gap.description,
+    }));
+    const nodes = [
+        {
+            id: 'current',
+            label: 'Current scan inputs',
+            kind: 'artifact',
+            description: 'Discovered source, tests, and optional specs',
+        },
+        {
+            id: 'suggested',
+            label: 'Suggested improvements',
+            kind: 'analysis',
+            description: 'Artifacts that would activate currently N/A metrics',
+        },
+        ...recommendations,
+    ];
+    const edges = recommendations.map((node) => ({
+        from: 'current',
+        to: node.id,
+        label: 'activate',
+    }));
+    if (recommendations.length > 0) {
+        edges.push({ from: 'suggested', to: recommendations[0].id, label: 'prioritize' });
+    }
+    return {
+        generatedAt: input.generatedAt,
+        projectRoot: input.rootDir,
+        nodes,
+        edges,
+        actionSteps,
+    };
+}
+function buildMetricReportPayload(result) {
+    var _a, _b, _c, _d, _e, _f;
+    const payload = {
+        generatedAt: new Date().toISOString(),
+        ...result,
+    };
+    if (result.type !== 'unit' || !result.details || typeof result.details !== 'object') {
+        return payload;
+    }
+    const details = result.details;
+    const ast = isRecord(details.ast) ? details.ast : undefined;
+    const dynamic = isRecord(details.dynamic) ? details.dynamic : undefined;
+    const coverage = isRecord(details.coverage) ? details.coverage : undefined;
+    const mutation = isRecord(details.mutation) ? details.mutation : undefined;
+    const smellItems = isRecord(details.testSmells) && Array.isArray(details.testSmells.items)
+        ? details.testSmells.items
+        : Array.isArray(details.smells)
+            ? details.smells
+            : [];
+    const slowTests = dynamic && Array.isArray(dynamic.slowTests)
+        ? dynamic.slowTests
+        : Array.isArray(details.slowTests)
+            ? details.slowTests
+            : [];
+    const lowCoverageFiles = Array.isArray(details.lowCoverageFiles)
+        ? details.lowCoverageFiles
+        : coverage && Array.isArray(coverage.lowCoverageFiles)
+            ? coverage.lowCoverageFiles
+            : [];
+    return {
+        ...payload,
+        astScore: asNumber(ast === null || ast === void 0 ? void 0 : ast.qualityScore),
+        weightedScore: asNumber(details.weightedScore),
+        enrichedByRuntime: Boolean(details.enrichedByRuntime),
+        enrichedByMutation: Boolean(details.enrichedByMutation),
+        lineCoverage: (_a = asNumber(details.lineCoverage)) !== null && _a !== void 0 ? _a : asNumber(coverage === null || coverage === void 0 ? void 0 : coverage.lineCoverage),
+        branchCoverage: (_b = asNumber(details.branchCoverage)) !== null && _b !== void 0 ? _b : asNumber(coverage === null || coverage === void 0 ? void 0 : coverage.branchCoverage),
+        methodCoverage: (_c = asNumber(details.methodCoverage)) !== null && _c !== void 0 ? _c : asNumber(coverage === null || coverage === void 0 ? void 0 : coverage.methodCoverage),
+        mutationScore: (_d = asNumber(details.mutationScore)) !== null && _d !== void 0 ? _d : asNumber(mutation === null || mutation === void 0 ? void 0 : mutation.mutationScore),
+        runtimeReportPath: (_e = asString(details.runtimeReportPath)) !== null && _e !== void 0 ? _e : asString(coverage === null || coverage === void 0 ? void 0 : coverage.reportPath),
+        smells: smellItems,
+        disabledTests: Array.isArray(ast === null || ast === void 0 ? void 0 : ast.disabledTests) ? ast.disabledTests : [],
+        slowTests,
+        lowCoverageFiles,
+        filesScanned: (_f = asNumber(details.filesScanned)) !== null && _f !== void 0 ? _f : asNumber(ast === null || ast === void 0 ? void 0 : ast.filesScanned),
+    };
+}
+function buildEnrichedArchitecturePayload(current, suggested, results) {
+    const prioritized = prioritizeArchitectureGaps(results);
+    const gaps = prioritized.map((gap, index) => {
+        const priority = architecturePriorityLabel(gap.priority);
+        const metricSlug = slugify(gap.label);
+        return {
+            id: `${metricSlug}-gap-${index + 1}`,
+            type: 'coverage-gap',
+            node: gap.label,
+            priority,
+            description: gap.description,
+            riskScore: Math.max(1, Math.min(100, gap.priority)),
+        };
+    });
+    const actionSteps = prioritized.map((gap, index) => {
+        var _a, _b;
+        const priority = architecturePriorityLabel(gap.priority);
+        const gapId = (_b = (_a = gaps[index]) === null || _a === void 0 ? void 0 : _a.id) !== null && _b !== void 0 ? _b : `gap-${index + 1}`;
+        return {
+            id: `step-${index + 1}`,
+            priority,
+            title: `${gap.label} follow-up`,
+            description: gap.step,
+            why: gap.description,
+            riskScore: Math.max(1, Math.min(100, gap.priority)),
+            codeSnippet: buildArchitectureCodeSnippet(gap.label, priority),
+            copilotPrompt: buildArchitectureCopilotPrompt(gap.label, gap.step, gap.description),
+            relatedGapIds: [gapId],
+        };
+    });
+    return {
+        mermaidCurrent: ['graph TD', ...renderMermaidGraph(current)].join('\n'),
+        mermaidSuggested: ['graph TD', ...renderMermaidGraph(suggested)].join('\n'),
+        gaps,
+        actionSteps,
+    };
+}
+function buildArchitectureMarkdown(current, suggested, results) {
+    const actionSteps = prioritizeArchitectureGaps(results)
+        .map((gap, index) => `${index + 1}. ${gap.step}`);
+    return [
+        '# Architecture Analysis',
+        '',
+        '## Current State',
+        '',
+        '```mermaid',
+        'graph TD',
+        ...renderMermaidGraph(current),
+        '```',
+        '',
+        '## Suggested State',
+        '',
+        '```mermaid',
+        'graph TD',
+        ...renderMermaidGraph(suggested),
+        '```',
+        '',
+        '## Action Steps',
+        '',
+        ...(actionSteps.length > 0 ? actionSteps : ['1. No architecture activation steps required.']),
+        '',
+    ].join('\n');
+}
+function buildMetricArchitectureNodes(results, mode) {
+    return sortResultsInKnownOrder(results)
+        .filter((result) => result.totalItems > 0 || result.reason)
+        .map((result) => {
+        const gapCount = Math.max(0, result.totalItems - result.coveredItems);
+        const labelPrefix = mode === 'current' ? metricTitle(result.type) : `${metricTitle(result.type)} target`;
+        return {
+            id: `${mode}-${result.type}`,
+            label: buildMetricArchitectureLabel(result, labelPrefix),
+            kind: result.totalItems === 0 || result.coveragePercent < 80 ? 'recommendation' : 'analysis',
+            description: result.totalItems === 0
+                ? result.reason
+                : buildMetricArchitectureDescription(result, gapCount),
+        };
+    });
+}
+function buildMetricArchitectureEdges(results, mode) {
+    return sortResultsInKnownOrder(results)
+        .filter((result) => result.totalItems > 0 || result.reason)
+        .map((result) => ({
+        from: mode === 'current' ? 'analyze' : 'suggested',
+        to: `${mode}-${result.type}`,
+        label: result.totalItems === 0 ? 'missing input' : 'coverage signal',
+    }));
+}
+function prioritizeArchitectureGaps(results) {
+    return sortResultsInKnownOrder(results)
+        .map((result) => {
+        var _a;
+        const uncovered = Math.max(0, result.totalItems - result.coveredItems);
+        const priority = result.totalItems === 0
+            ? 100
+            : uncovered > 0
+                ? Math.round((uncovered / Math.max(1, result.totalItems)) * 100)
+                : 0;
+        return {
+            label: metricTitle(result.type),
+            description: result.totalItems === 0
+                ? (_a = result.reason) !== null && _a !== void 0 ? _a : 'Add supporting inputs and rerun analyze.'
+                : buildGapPriorityDescription(result, uncovered),
+            step: buildArchitectureActionStep(result, uncovered),
+            priority,
+        };
+    })
+        .filter((gap) => gap.priority > 0)
+        .sort((a, b) => b.priority - a.priority || a.label.localeCompare(b.label));
+}
+function buildMetricArchitectureLabel(result, labelPrefix) {
+    if (result.type === 'unit' && result.totalItems > 0) {
+        return `${labelPrefix}: ${Math.round(result.coveragePercent)}% (${result.coveredItems}/${result.totalItems})`;
+    }
+    return `${labelPrefix}: ${result.coveredItems}/${result.totalItems}`;
+}
+function buildMetricArchitectureDescription(result, gapCount) {
+    if (gapCount > 0) {
+        return result.type === 'unit'
+            ? `${gapCount} weighted-quality ${gapCount === 1 ? 'gap remains' : 'gaps remain'} (${Math.round(result.coveragePercent)}% quality score). See ${detailPathForMetric(result.type)}`
+            : `${gapCount} gaps remain (${Math.round(result.coveragePercent)}% coverage). See ${detailPathForMetric(result.type)}`;
+    }
+    return result.type === 'unit'
+        ? `Healthy quality score (${Math.round(result.coveragePercent)}%).`
+        : `Healthy coverage (${Math.round(result.coveragePercent)}%).`;
+}
+function buildGapPriorityDescription(result, uncovered) {
+    return result.type === 'unit'
+        ? `${uncovered} weighted-quality ${uncovered === 1 ? 'gap' : 'gaps'} of ${result.totalItems} (${Math.round(result.coveragePercent)}% quality score).`
+        : `${uncovered} uncovered of ${result.totalItems} (${Math.round(result.coveragePercent)}% coverage).`;
+}
+function buildArchitectureActionStep(result, uncovered) {
+    var _a;
+    if (result.totalItems === 0) {
+        return `${metricTitle(result.type)}: ${(_a = result.reason) !== null && _a !== void 0 ? _a : 'Add supporting inputs and rerun analyze.'}`;
+    }
+    return `${metricTitle(result.type)}: close ${uncovered} remaining gaps and re-run analyze (${detailPathForMetric(result.type)}).`;
+}
+function buildArchitectureCodeSnippet(label, priority) {
+    return [
+        `# ${label}`,
+        `priority: ${priority}`,
+        'action: rerun analyze after closing the reported gap',
+    ].join('\n');
+}
+function buildArchitectureCopilotPrompt(label, step, why) {
+    return [
+        `Improve ${label} in this repository.`,
+        `Action: ${step}`,
+        `Reason: ${why}`,
+        'Update the relevant implementation or tests, then rerun the analyzer.',
+    ].join(' ');
+}
+function architecturePriorityLabel(priority) {
+    if (priority >= 75)
+        return 'P0';
+    if (priority >= 40)
+        return 'P1';
+    return 'P2';
+}
+function slugify(value) {
+    return value.toLowerCase().replace(/[^a-z0-9]+/g, '-').replace(/^-+|-+$/g, '');
+}
+function escapeMermaidId(value) {
+    const sanitized = value.replace(/[^a-zA-Z0-9_]/g, '_');
+    return /^[A-Za-z]/.test(sanitized) ? sanitized : `node_${sanitized}`;
+}
+function escapeMermaidText(value) {
+    return value
+        .replace(/["`\[\]\n\r]/g, ' ')
+        .replace(/\s+/g, ' ')
+        .trim();
+}
+async function fetchUrlText(url) {
+    if (!isAllowedSpecUrl(url)) {
+        return undefined;
+    }
+    const transport = url.startsWith('https:') ? https : http;
+    return new Promise((resolve) => {
+        const request = transport.get(url, { timeout: 1500 }, (response) => {
+            var _a;
+            if (((_a = response.statusCode) !== null && _a !== void 0 ? _a : 500) >= 400) {
+                response.resume();
+                resolve(undefined);
+                return;
+            }
+            let body = '';
+            response.setEncoding('utf-8');
+            response.on('data', (chunk) => {
+                body += chunk;
+            });
+            response.on('end', () => resolve(body));
+        });
+        request.on('timeout', () => {
+            request.destroy();
+            resolve(undefined);
+        });
+        request.on('error', () => resolve(undefined));
+    });
+}
+function renderMermaidGraph(snapshot) {
+    const aliasById = new Map();
+    snapshot.nodes.forEach((node, index) => {
+        aliasById.set(node.id, `${escapeMermaidId(node.id)}_${index}`);
+    });
+    return [
+        ...snapshot.nodes.map((node) => `  ${aliasById.get(node.id)}["${escapeMermaidText(node.label)}"]`),
+        ...snapshot.edges
+            .filter((edge) => aliasById.has(edge.from) && aliasById.has(edge.to))
+            .map((edge) => { var _a; return `  ${aliasById.get(edge.from)} -->|${escapeMermaidText((_a = edge.label) !== null && _a !== void 0 ? _a : '')}| ${aliasById.get(edge.to)}`; }),
+    ];
+}
+function isAllowedSpecUrl(candidate) {
+    try {
+        const parsed = new URL(candidate);
+        return (parsed.protocol === 'http:' || parsed.protocol === 'https:')
+            && ['localhost', '127.0.0.1'].includes(parsed.hostname);
+    }
+    catch {
+        return false;
+    }
+}
+function isRecord(value) {
+    return typeof value === 'object' && value !== null;
+}
+function asNumber(value) {
+    return typeof value === 'number' ? value : undefined;
+}
+function asString(value) {
+    return typeof value === 'string' ? value : undefined;
+}

package/dist/src/config/defaultConfig.js

@@ -138,7 +138,7 @@ exports.DEFAULT_CONFIG = {
             },
         },
         mutationTesting: {
-            enabled: false,
+            enabled: true,
             tool: 'auto',
             threshold: 70,
             scope: 'changed-files',