norn-cli 1.6.0 → 1.6.2

package/out/coverageCalculator.js

@@ -1,837 +0,0 @@
-"use strict";
-/**
- * Coverage Calculator for Swagger/OpenAPI specs
- *
- * Calculates what percentage of swagger-defined endpoints and their
- * response codes are covered by test sequences.
- */
-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.calculateWorkspaceCoverage = calculateWorkspaceCoverage;
-exports.getCoverage = getCoverage;
-exports.getCoverageForNornapiFile = getCoverageForNornapiFile;
-exports.refreshCoverage = refreshCoverage;
-exports.refreshCoverageForNornapiFile = refreshCoverageForNornapiFile;
-exports.recalculateCoverageAfterExecution = recalculateCoverageAfterExecution;
-exports.clearCoverageCache = clearCoverageCache;
-exports.onCoverageUpdate = onCoverageUpdate;
-const vscode = __importStar(require("vscode"));
-const fs = __importStar(require("fs"));
-const path = __importStar(require("path"));
-const swaggerParser_1 = require("./swaggerParser");
-const nornapiParser_1 = require("./nornapiParser");
-/**
- * Extract the path portion from a full URL and normalize it for swagger matching.
- * e.g., "https://petstore.swagger.io/v2/store/inventory" -> "/store/inventory"
- *
- * We need to strip the base URL (which typically includes version like /v2) to match swagger paths.
- */
-function extractSwaggerPath(fullUrl, swaggerBaseUrl) {
-    const normalizeWithBasePath = (rawPath) => {
-        let normalizedPath = rawPath || '/';
-        try {
-            normalizedPath = decodeURIComponent(normalizedPath);
-        }
-        catch {
-            // Keep original path if decoding fails
-        }
-        if (!normalizedPath.startsWith('/')) {
-            normalizedPath = `/${normalizedPath}`;
-        }
-        if (swaggerBaseUrl) {
-            try {
-                const baseUrl = new URL(swaggerBaseUrl);
-                const basePath = decodeURIComponent(baseUrl.pathname);
-                if (basePath && basePath !== '/' && normalizedPath.startsWith(basePath)) {
-                    normalizedPath = normalizedPath.substring(basePath.length);
-                    if (!normalizedPath.startsWith('/')) {
-                        normalizedPath = '/' + normalizedPath;
-                    }
-                }
-            }
-            catch {
-                // Ignore base URL parsing errors
-            }
-        }
-        return normalizedPath || '/';
-    };
-    const normalizeTemplatePath = (rawPath) => {
-        let candidate = rawPath.trim();
-        if (!candidate.startsWith('/')) {
-            candidate = `/${candidate}`;
-        }
-        // Remove one or more leading template segments such as
-        // /{{baseUrl}}/{{version}}/pet/{petId} -> /pet/{petId}
-        candidate = candidate.replace(/^(?:\/\{\{[^}]+\}\})+/, '');
-        if (!candidate.startsWith('/')) {
-            candidate = `/${candidate}`;
-        }
-        return normalizeWithBasePath(candidate);
-    };
-    try {
-        const trimmed = fullUrl.trim();
-        // Handle template variables such as {{baseUrl}}/pet/{petId}
-        const variablePrefixMatch = trimmed.match(/^\{\{[^}]+\}\}(.*)$/);
-        if (variablePrefixMatch) {
-            const remainder = variablePrefixMatch[1] || '/';
-            return normalizeTemplatePath(remainder);
-        }
-        // Handle path-form template segments such as /{{version}}/pet/{petId}
-        if (/^\/(?:\{\{[^}]+\}\}\/)+/.test(trimmed) || /^\/\{\{[^}]+\}\}$/.test(trimmed)) {
-            return normalizeTemplatePath(trimmed);
-        }
-        // If it's already just a path (starts with /), return as-is
-        if (trimmed.startsWith('/')) {
-            return normalizeWithBasePath(trimmed);
-        }
-        const url = new URL(trimmed);
-        return normalizeWithBasePath(url.pathname);
-    }
-    catch {
-        // If URL parsing fails, try to extract path manually
-        const match = fullUrl.match(/https?:\/\/[^\/]+(\/.*)/);
-        if (match) {
-            return normalizeWithBasePath(match[1]);
-        }
-        return normalizeWithBasePath(fullUrl);
-    }
-}
-/**
- * Extract swagger URL from .nornapi file content
- */
-function extractSwaggerUrl(content) {
-    const match = content.match(/^swagger\s+["']?(https?:\/\/[^\s"']+)["']?\s*$/m);
-    return match?.[1];
-}
-/**
- * Parse assert status lines from sequence content.
- * Returns array of status codes/patterns (e.g., ["200", "2xx", "404"])
- */
-function extractAssertedStatusCodes(sequenceContent) {
-    const codes = [];
-    const lines = sequenceContent.split('\n');
-    for (const line of lines) {
-        const code = extractStatusCodeFromAssert(line);
-        if (code) {
-            codes.push(code);
-        }
-    }
-    return codes;
-}
-function extractStatusCodeFromAssert(line) {
-    const trimmed = line.trim();
-    // Match various assert status patterns:
-    // - assert status == 200
-    // - assert $1.status == 200
-    // - assert response.status == 200
-    // - assert inventory.status == 200
-    // - assert variableName.status >= 400
-    const statusMatch = trimmed.match(/^assert\s+(?:(?:\$\d+|[a-zA-Z_][a-zA-Z0-9_]*)\.)?status\s*(?:==|>=|<=|>|<|!=)?\s*(\d{3}|[1-5]xx)$/i);
-    if (statusMatch) {
-        return statusMatch[1].toLowerCase();
-    }
-    // Also match simpler patterns like: assert status 200
-    const simpleMatch = trimmed.match(/^assert\s+status\s+(\d{3}|[1-5]xx)$/i);
-    if (simpleMatch) {
-        return simpleMatch[1].toLowerCase();
-    }
-    return null;
-}
-function isCoverageScanBoundary(line) {
-    return /^(?:var\s+[a-zA-Z_][a-zA-Z0-9_]*\s*=\s*)?(GET|POST|PUT|DELETE|PATCH|HEAD|OPTIONS)\s+/i.test(line) ||
-        /^end\s+sequence$/i.test(line) ||
-        /^(?:var\s+[a-zA-Z_][a-zA-Z0-9_]*\s*=\s*)?run\s+/i.test(line) ||
-        /^if\s+/i.test(line) ||
-        /^foreach\s+/i.test(line);
-}
-function collectStatusAssertionsFollowingLine(lines, startIndex) {
-    const assertedCodes = [];
-    for (let j = startIndex + 1; j < lines.length; j++) {
-        const nextLine = lines[j].trim();
-        // Stop at next request, sequence end, or other control flow
-        if (isCoverageScanBoundary(nextLine)) {
-            break;
-        }
-        const code = extractStatusCodeFromAssert(nextLine);
-        if (code) {
-            assertedCodes.push(code);
-        }
-    }
-    return assertedCodes;
-}
-function extractReturnedVariable(sequenceContent) {
-    let returnedVariable;
-    for (const line of sequenceContent.split('\n')) {
-        const trimmed = line.trim();
-        const returnMatch = trimmed.match(/^return\s+([a-zA-Z_][a-zA-Z0-9_]*)$/i);
-        if (returnMatch) {
-            returnedVariable = returnMatch[1];
-        }
-    }
-    return returnedVariable;
-}
-/**
- * Check if a wildcard pattern matches a status code
- * e.g., "2xx" matches "200", "201", "204"
- */
-function wildcardMatches(pattern, code) {
-    const lowerPattern = pattern.toLowerCase();
-    // Exact match
-    if (lowerPattern === code) {
-        return true;
-    }
-    // Wildcard match (2xx, 4xx, 5xx)
-    if (/^[1-5]xx$/.test(lowerPattern)) {
-        const patternPrefix = lowerPattern[0];
-        return code.startsWith(patternPrefix);
-    }
-    return false;
-}
-/**
- * Check if a concrete URL path matches a swagger endpoint path template
- * e.g., "/pet/1" matches "/pet/{petId}"
- *       "/v2/pet/123" matches "/pet/{petId}" (with base path /v2)
- */
-function pathMatchesSwaggerEndpoint(urlPath, swaggerPath) {
-    // Normalize paths - remove leading/trailing slashes for comparison
-    const normalizedUrl = urlPath.replace(/^\/+|\/+$/g, '');
-    const normalizedSwagger = swaggerPath.replace(/^\/+|\/+$/g, '');
-    const urlParts = normalizedUrl.split('/');
-    const swaggerParts = normalizedSwagger.split('/');
-    // Try matching from different starting positions to handle base paths
-    // e.g., URL /v2/pet/1 should match swagger /pet/{petId} if base is /v2
-    for (let offset = 0; offset <= urlParts.length - swaggerParts.length; offset++) {
-        let matches = true;
-        for (let i = 0; i < swaggerParts.length; i++) {
-            const urlPart = urlParts[offset + i];
-            const swaggerPart = swaggerParts[i];
-            // Path parameter in swagger (e.g., {petId}) matches any value
-            if (swaggerPart.startsWith('{') && swaggerPart.endsWith('}')) {
-                // Path parameter matches any non-empty value
-                if (!urlPart || urlPart.length === 0) {
-                    matches = false;
-                    break;
-                }
-            }
-            else if (urlPart !== swaggerPart) {
-                // Static segments must match exactly
-                matches = false;
-                break;
-            }
-        }
-        if (matches) {
-            return true;
-        }
-    }
-    return false;
-}
-/**
- * Extract API calls from sequence content.
- * Returns array of { endpointName, assertedCodes, method?, url? }
- *
- * @param sequenceContent - The content of the sequence to analyze
- * @param allSequences - Map of all sequences by name (for following run SequenceName calls)
- * @param allNamedRequests - Map of named request blocks by name (for following run NamedRequest calls)
- * @param visited - Set of already visited sequence names (to prevent infinite recursion)
- */
-function extractApiCalls(sequenceContent, allSequences, allNamedRequests, visited) {
-    const calls = [];
-    const lines = sequenceContent.split('\n');
-    const visitedSet = visited || new Set();
-    for (let i = 0; i < lines.length; i++) {
-        const line = lines[i].trim();
-        // Check for "run Name" or "var x = run Name" calls
-        const runMatch = line.match(/^(?:var\s+([a-zA-Z_][a-zA-Z0-9_]*)\s*=\s*)?run\s+([a-zA-Z_][a-zA-Z0-9_-]*)(?:\s*\(.*?\))?$/i);
-        if (runMatch) {
-            const assignedVar = runMatch[1];
-            const targetName = runMatch[2];
-            const assertedCodesAfterRun = collectStatusAssertionsFollowingLine(lines, i);
-            // Avoid infinite recursion
-            if (!visitedSet.has(targetName)) {
-                visitedSet.add(targetName);
-                // First check if it's a sequence
-                if (allSequences) {
-                    const subSequenceContent = allSequences.get(targetName);
-                    if (subSequenceContent) {
-                        // Recursively extract API calls from the sub-sequence
-                        const subCalls = extractApiCalls(subSequenceContent, allSequences, allNamedRequests, visitedSet);
-                        // If caller asserts status after "run Sequence", apply those assertions
-                        // to the response returned by that sequence (fallback: last API call).
-                        if (assertedCodesAfterRun.length > 0 && subCalls.length > 0) {
-                            const returnedVar = extractReturnedVariable(subSequenceContent);
-                            const returnedCall = returnedVar
-                                ? [...subCalls].reverse().find(call => call.assignedVar === returnedVar) || subCalls[subCalls.length - 1]
-                                : subCalls[subCalls.length - 1];
-                            returnedCall.assertedCodes.push(...assertedCodesAfterRun);
-                        }
-                        calls.push(...subCalls);
-                        continue;
-                    }
-                }
-                // Then check if it's a named request block
-                if (allNamedRequests) {
-                    const namedRequest = allNamedRequests.get(targetName);
-                    if (namedRequest) {
-                        // Add this as a URL-based API call (will be matched by URL later)
-                        calls.push({
-                            endpointName: `__url__${namedRequest.method}__${namedRequest.url}`,
-                            assertedCodes: assertedCodesAfterRun,
-                            method: namedRequest.method,
-                            url: namedRequest.url,
-                            assignedVar
-                        });
-                        continue;
-                    }
-                }
-            }
-            continue;
-        }
-        // Match API request by name with optional variable assignment:
-        // - GET EndpointName
-        // - GET EndpointName(args)
-        // - GET EndpointName(args) HeaderGroup
-        // - var result = GET EndpointName
-        // - var inventory = GET GetInventory
-        // - var order = GET GetOrderById(1)
-        const apiCallMatch = line.match(/^(?:var\s+([a-zA-Z_][a-zA-Z0-9_]*)\s*=\s*)?(GET|POST|PUT|DELETE|PATCH|HEAD|OPTIONS)\s+([a-zA-Z_][a-zA-Z0-9_]*)(?:\s*\(.*?\))?(?:\s+[a-zA-Z_][a-zA-Z0-9_]*)?$/i);
-        if (apiCallMatch) {
-            const assignedVar = apiCallMatch[1];
-            const endpointName = apiCallMatch[3];
-            const assertedCodes = collectStatusAssertionsFollowingLine(lines, i);
-            calls.push({ endpointName, assertedCodes, assignedVar });
-        }
-    }
-    return calls;
-}
-/**
- * Extract all test sequences from a .norn file content.
- * Only "test sequence" blocks count towards coverage, not regular "sequence" blocks.
- */
-function extractTestSequences(content) {
-    const sequences = [];
-    const lines = content.split('\n');
-    let currentSequence = null;
-    for (let i = 0; i < lines.length; i++) {
-        const line = lines[i].trim();
-        // Match only "test sequence Name" - regular sequences don't count towards coverage
-        const sequenceMatch = line.match(/^test\s+sequence\s+([a-zA-Z_][a-zA-Z0-9_-]*)(?:\s*\([^)]*\))?$/);
-        if (sequenceMatch) {
-            currentSequence = { name: sequenceMatch[1], startLine: i };
-            continue;
-        }
-        // Match sequence end
-        if (/^end\s+sequence$/i.test(line) && currentSequence) {
-            const sequenceContent = lines.slice(currentSequence.startLine, i + 1).join('\n');
-            sequences.push({ name: currentSequence.name, content: sequenceContent });
-            currentSequence = null;
-        }
-    }
-    return sequences;
-}
-/**
- * Extract ALL sequences from a .norn file content (both test and regular).
- * Used to build a map for following "run SequenceName" calls.
- */
-function extractAllSequences(content) {
-    const sequences = new Map();
-    const lines = content.split('\n');
-    let currentSequence = null;
-    for (let i = 0; i < lines.length; i++) {
-        const line = lines[i].trim();
-        // Match both "test sequence Name" and "sequence Name"
-        const testSequenceMatch = line.match(/^test\s+sequence\s+([a-zA-Z_][a-zA-Z0-9_-]*)(?:\s*\([^)]*\))?$/);
-        const sequenceMatch = line.match(/^sequence\s+([a-zA-Z_][a-zA-Z0-9_-]*)(?:\s*\([^)]*\))?$/);
-        if (testSequenceMatch || sequenceMatch) {
-            const name = testSequenceMatch ? testSequenceMatch[1] : sequenceMatch[1];
-            currentSequence = { name, startLine: i };
-            continue;
-        }
-        // Match sequence end
-        if (/^end\s+sequence$/i.test(line) && currentSequence) {
-            const sequenceContent = lines.slice(currentSequence.startLine + 1, i).join('\n');
-            sequences.set(currentSequence.name, sequenceContent);
-            currentSequence = null;
-        }
-    }
-    return sequences;
-}
-/**
- * Extract named request blocks from a .norn file content.
- * Named requests are blocks like [RequestName] followed by HTTP method + URL.
- */
-function extractNamedRequests(content) {
-    const requests = new Map();
-    const lines = content.split('\n');
-    let currentRequest = null;
-    for (let i = 0; i < lines.length; i++) {
-        const line = lines[i].trim();
-        // Match named request start: [RequestName]
-        const nameMatch = line.match(/^\[([a-zA-Z_][a-zA-Z0-9_-]*)\]$/);
-        if (nameMatch) {
-            // Save previous request if exists
-            if (currentRequest) {
-                const requestContent = lines.slice(currentRequest.startLine + 1, i).join('\n').trim();
-                const parsed = parseRequestContent(requestContent);
-                if (parsed) {
-                    requests.set(currentRequest.name, { ...parsed, content: requestContent });
-                }
-            }
-            currentRequest = { name: nameMatch[1], startLine: i };
-            continue;
-        }
-        // Check for sequence start or end - terminates named request block
-        if (/^(?:test\s+)?sequence\s+/i.test(line) || /^end\s+sequence$/i.test(line)) {
-            if (currentRequest) {
-                const requestContent = lines.slice(currentRequest.startLine + 1, i).join('\n').trim();
-                const parsed = parseRequestContent(requestContent);
-                if (parsed) {
-                    requests.set(currentRequest.name, { ...parsed, content: requestContent });
-                }
-                currentRequest = null;
-            }
-        }
-    }
-    // Don't forget the last request
-    if (currentRequest) {
-        const requestContent = lines.slice(currentRequest.startLine + 1).join('\n').trim();
-        const parsed = parseRequestContent(requestContent);
-        if (parsed) {
-            requests.set(currentRequest.name, { ...parsed, content: requestContent });
-        }
-    }
-    return requests;
-}
-/**
- * Parse the content of a named request block to extract method and URL.
- */
-function parseRequestContent(content) {
-    const lines = content.split('\n');
-    for (const line of lines) {
-        const trimmed = line.trim();
-        // Match: GET "url" or GET url or POST "url" etc.
-        const match = trimmed.match(/^(GET|POST|PUT|DELETE|PATCH|HEAD|OPTIONS)\s+["']?([^"'\s]+)["']?/i);
-        if (match) {
-            return { method: match[1].toUpperCase(), url: match[2] };
-        }
-    }
-    return null;
-}
-function isPathAtOrBelowRoot(filePath, rootPath) {
-    const relative = path.relative(rootPath, filePath);
-    return relative === '' || (!relative.startsWith('..') && !path.isAbsolute(relative));
-}
-function buildScopedCoverage(nornFiles) {
-    const byName = new Map();
-    const byUrl = new Map();
-    const allSequencesMap = new Map();
-    const allNamedRequestsMap = new Map();
-    for (const file of nornFiles) {
-        try {
-            const content = fs.readFileSync(file.fsPath, 'utf-8');
-            const fileSequences = extractAllSequences(content);
-            for (const [name, seqContent] of fileSequences) {
-                allSequencesMap.set(name, seqContent);
-            }
-            const fileNamedRequests = extractNamedRequests(content);
-            for (const [name, reqInfo] of fileNamedRequests) {
-                allNamedRequestsMap.set(name, reqInfo);
-            }
-        }
-        catch (error) {
-            console.error(`Error reading .norn file ${file.fsPath}:`, error);
-        }
-    }
-    for (const file of nornFiles) {
-        try {
-            const content = fs.readFileSync(file.fsPath, 'utf-8');
-            const testSequences = extractTestSequences(content);
-            for (const sequence of testSequences) {
-                const apiCalls = extractApiCalls(sequence.content, allSequencesMap, allNamedRequestsMap);
-                for (const call of apiCalls) {
-                    if (call.url && call.method) {
-                        const key = `${call.method} ${call.url}`;
-                        if (!byUrl.has(key)) {
-                            byUrl.set(key, { method: call.method, url: call.url, assertedCodes: new Set() });
-                        }
-                        for (const code of call.assertedCodes) {
-                            byUrl.get(key).assertedCodes.add(code);
-                        }
-                    }
-                    else {
-                        if (!byName.has(call.endpointName)) {
-                            byName.set(call.endpointName, new Set());
-                        }
-                        for (const code of call.assertedCodes) {
-                            byName.get(call.endpointName).add(code);
-                        }
-                    }
-                }
-            }
-        }
-        catch (error) {
-            console.error(`Error reading .norn file ${file.fsPath}:`, error);
-        }
-    }
-    return { byName, byUrl };
-}
-/**
- * Calculate coverage for the entire workspace
- * @param useCachedSpecs If true, only fetch swagger specs for new URLs (used after execution)
- */
-async function calculateWorkspaceCoverage(useCachedSpecs = false, scopedNornapiFilePath) {
-    const workspaceFolders = vscode.workspace.workspaceFolders;
-    if (!workspaceFolders) {
-        return {
-            total: 0,
-            covered: 0,
-            percentage: 0,
-            specs: [],
-            hasSwagger: false
-        };
-    }
-    // Step 1: Find all .nornapi files and extract swagger URLs + endpoint mappings
-    const allNornapiFiles = await vscode.workspace.findFiles('**/*.nornapi', '**/node_modules/**');
-    const normalizedScopedPath = scopedNornapiFilePath ? path.resolve(scopedNornapiFilePath) : undefined;
-    const nornapiFiles = normalizedScopedPath
-        ? allNornapiFiles.filter(file => path.resolve(file.fsPath) === normalizedScopedPath)
-        : allNornapiFiles;
-    const swaggerUrls = new Map(); // swagger URL -> list of nornapi files
-    // Store endpoint info temporarily - we'll create mappings after fetching swagger specs
-    const pendingEndpoints = [];
-    for (const file of nornapiFiles) {
-        try {
-            const content = fs.readFileSync(file.fsPath, 'utf-8');
-            const swaggerUrl = extractSwaggerUrl(content);
-            if (swaggerUrl) {
-                // Track this nornapi file for this swagger URL
-                if (!swaggerUrls.has(swaggerUrl)) {
-                    swaggerUrls.set(swaggerUrl, []);
-                }
-                swaggerUrls.get(swaggerUrl).push({ url: swaggerUrl, filePath: file.fsPath });
-                // Parse endpoints from this nornapi file
-                const nornApiDef = (0, nornapiParser_1.parseNornApiFile)(content);
-                for (const endpoint of nornApiDef.endpoints) {
-                    // Store for later processing after we have swagger specs
-                    pendingEndpoints.push({
-                        endpoint: { name: endpoint.name, method: endpoint.method, path: endpoint.path },
-                        swaggerUrl,
-                        filePath: file.fsPath
-                    });
-                }
-            }
-        }
-        catch (error) {
-            console.error(`Error reading .nornapi file ${file.fsPath}:`, error);
-        }
-    }
-    if (swaggerUrls.size === 0) {
-        return {
-            total: 0,
-            covered: 0,
-            percentage: 0,
-            specs: [],
-            hasSwagger: false
-        };
-    }
-    // Detect new swagger URLs (not seen before)
-    const currentUrls = new Set(swaggerUrls.keys());
-    const newUrls = new Set();
-    for (const url of currentUrls) {
-        if (!knownSwaggerUrls.has(url)) {
-            newUrls.add(url);
-        }
-    }
-    // Update known URLs
-    knownSwaggerUrls = currentUrls;
-    // Step 2: Find all .norn files and extract API calls with assert status
-    const nornFiles = await vscode.workspace.findFiles('**/*.norn', '**/node_modules/**');
-    const scopedCoverageByRoot = new Map();
-    const uniqueNornapiRoots = Array.from(new Set(nornapiFiles.map(file => path.dirname(file.fsPath))));
-    for (const root of uniqueNornapiRoots) {
-        const scopedFiles = nornFiles.filter(file => isPathAtOrBelowRoot(file.fsPath, root));
-        scopedCoverageByRoot.set(root, buildScopedCoverage(scopedFiles));
-    }
-    // Step 3: For each swagger spec, calculate coverage
-    // First fetch all specs so we have baseUrl for path normalization
-    const swaggerSpecs = new Map();
-    for (const [swaggerUrl] of swaggerUrls) {
-        try {
-            const swaggerSpec = await (0, swaggerParser_1.getCachedSwaggerSpec)(swaggerUrl);
-            swaggerSpecs.set(swaggerUrl, swaggerSpec);
-        }
-        catch (error) {
-            console.error(`Error fetching swagger spec ${swaggerUrl}:`, error);
-        }
-    }
-    // Now create endpoint mappings with proper path normalization
-    const endpointMappings = [];
-    for (const pending of pendingEndpoints) {
-        const spec = swaggerSpecs.get(pending.swaggerUrl);
-        if (spec) {
-            // Extract the swagger-style path from the full URL
-            const swaggerPath = extractSwaggerPath(pending.endpoint.path, spec.baseUrl);
-            const swaggerKey = `${pending.endpoint.method} ${swaggerPath}`;
-            endpointMappings.push({
-                name: pending.endpoint.name,
-                swaggerKey,
-                swaggerUrl: pending.swaggerUrl,
-                filePath: pending.filePath
-            });
-        }
-    }
-    const specs = [];
-    for (const [swaggerUrl, swaggerSpec] of swaggerSpecs) {
-        const coverageResult = calculateCoverageForSpec(swaggerUrl, swaggerSpec, endpointMappings.filter(m => m.swaggerUrl === swaggerUrl), scopedCoverageByRoot);
-        specs.push(coverageResult);
-    }
-    // Step 4: Aggregate results
-    let totalCodes = 0;
-    let coveredCodes = 0;
-    for (const spec of specs) {
-        totalCodes += spec.total;
-        coveredCodes += spec.covered;
-    }
-    return {
-        total: totalCodes,
-        covered: coveredCodes,
-        percentage: totalCodes > 0 ? Math.round((coveredCodes / totalCodes) * 100) : 0,
-        specs,
-        hasSwagger: true
-    };
-}
-/**
- * Calculate coverage for a single swagger spec
- */
-function calculateCoverageForSpec(swaggerUrl, spec, endpointMappings, scopedCoverageByRoot) {
-    const endpoints = [];
-    let total = 0;
-    let covered = 0;
-    // Build a lookup from swagger key to mapped .nornapi endpoints (with source file context)
-    const keyToMappings = new Map();
-    for (const mapping of endpointMappings) {
-        if (!keyToMappings.has(mapping.swaggerKey)) {
-            keyToMappings.set(mapping.swaggerKey, []);
-        }
-        keyToMappings.get(mapping.swaggerKey).push(mapping);
-    }
-    // Process each endpoint in the swagger spec
-    for (const section of spec.sections) {
-        for (const endpoint of section.endpoints) {
-            const swaggerKey = `${endpoint.method} ${endpoint.path}`;
-            const mappingsForEndpoint = keyToMappings.get(swaggerKey) || [];
-            // Get all asserted codes for any name that maps to this endpoint
-            const allAssertedCodes = new Set();
-            const coveredByNames = {}; // code -> names that cover it
-            const endpointRootPaths = new Set();
-            for (const mapping of mappingsForEndpoint) {
-                const rootPath = path.dirname(mapping.filePath);
-                endpointRootPaths.add(rootPath);
-                const scopedCoverage = scopedCoverageByRoot.get(rootPath);
-                const codes = scopedCoverage?.byName.get(mapping.name);
-                if (codes) {
-                    for (const code of codes) {
-                        allAssertedCodes.add(code);
-                        // Track which names cover which codes
-                        for (const responseCode of endpoint.responseCodes) {
-                            if (wildcardMatches(code, responseCode)) {
-                                if (!coveredByNames[responseCode]) {
-                                    coveredByNames[responseCode] = [];
-                                }
-                                if (!coveredByNames[responseCode].includes(mapping.name)) {
-                                    coveredByNames[responseCode].push(mapping.name);
-                                }
-                            }
-                        }
-                    }
-                }
-            }
-            // Also check URL-based coverage (from named request blocks)
-            // Match URLs to swagger endpoints by comparing the path portion
-            for (const rootPath of endpointRootPaths) {
-                const scopedCoverage = scopedCoverageByRoot.get(rootPath);
-                if (!scopedCoverage) {
-                    continue;
-                }
-                for (const [, urlCoverage] of scopedCoverage.byUrl) {
-                    // Check if method matches
-                    if (urlCoverage.method.toUpperCase() !== endpoint.method.toUpperCase()) {
-                        continue;
-                    }
-                    // Try to match URL to swagger endpoint path
-                    // Extract the path from the full URL
-                    try {
-                        const url = new URL(urlCoverage.url);
-                        const urlPath = url.pathname;
-                        // Check if URL path matches the swagger endpoint path
-                        // Handle path parameters like /pet/{petId} matching /pet/1
-                        if (pathMatchesSwaggerEndpoint(urlPath, endpoint.path)) {
-                            for (const code of urlCoverage.assertedCodes) {
-                                allAssertedCodes.add(code);
-                            }
-                        }
-                    }
-                    catch {
-                        // Invalid URL, skip
-                    }
-                }
-            }
-            // Calculate coverage for each response code
-            const responseCodes = [];
-            let endpointCovered = 0;
-            for (const code of endpoint.responseCodes) {
-                let isCovered = false;
-                const coveredBy = coveredByNames[code] || [];
-                // Check if any asserted code matches this response code
-                for (const assertedCode of allAssertedCodes) {
-                    if (wildcardMatches(assertedCode, code)) {
-                        isCovered = true;
-                        break;
-                    }
-                }
-                responseCodes.push({
-                    code,
-                    covered: isCovered,
-                    coveredBy
-                });
-                total++;
-                if (isCovered) {
-                    covered++;
-                    endpointCovered++;
-                }
-            }
-            endpoints.push({
-                method: endpoint.method,
-                path: endpoint.path,
-                tag: endpoint.tag,
-                summary: endpoint.summary,
-                responseCodes,
-                totalCodes: endpoint.responseCodes.length,
-                coveredCodes: endpointCovered
-            });
-        }
-    }
-    // Sort endpoints by tag, then by path
-    endpoints.sort((a, b) => {
-        if (a.tag !== b.tag) {
-            return a.tag.localeCompare(b.tag);
-        }
-        return a.path.localeCompare(b.path);
-    });
-    return {
-        total,
-        covered,
-        percentage: total > 0 ? Math.round((covered / total) * 100) : 0,
-        endpoints,
-        swaggerUrl,
-        swaggerTitle: spec.title,
-        lastUpdated: new Date()
-    };
-}
-// Cached coverage result for status bar updates
-let cachedCoverage = null;
-let coverageUpdateListeners = [];
-// Track known swagger URLs to detect new ones
-let knownSwaggerUrls = new Set();
-/**
- * Get cached coverage or calculate if not available
- */
-async function getCoverage() {
-    if (!cachedCoverage) {
-        cachedCoverage = await calculateWorkspaceCoverage();
-        notifyCoverageListeners();
-    }
-    return cachedCoverage;
-}
-/**
- * Calculate coverage scoped to a specific .nornapi file.
- * Includes tests from that file's directory and descendants only.
- */
-async function getCoverageForNornapiFile(nornapiFilePath) {
-    return calculateWorkspaceCoverage(false, nornapiFilePath);
-}
-/**
- * Force recalculate coverage - re-fetches swagger specs
- */
-async function refreshCoverage() {
-    cachedCoverage = await calculateWorkspaceCoverage();
-    notifyCoverageListeners();
-    return cachedCoverage;
-}
-/**
- * Refresh coverage scoped to a specific .nornapi file.
- */
-async function refreshCoverageForNornapiFile(nornapiFilePath) {
-    return calculateWorkspaceCoverage(false, nornapiFilePath);
-}
-/**
- * Recalculate coverage after execution - only re-scans .norn files,
- * uses cached swagger specs unless new URLs are detected
- */
-async function recalculateCoverageAfterExecution() {
-    cachedCoverage = await calculateWorkspaceCoverage(true);
-    notifyCoverageListeners();
-    return cachedCoverage;
-}
-/**
- * Clear cached coverage
- */
-function clearCoverageCache() {
-    cachedCoverage = null;
-}
-/**
- * Register a listener for coverage updates
- */
-function onCoverageUpdate(listener) {
-    coverageUpdateListeners.push(listener);
-    return {
-        dispose: () => {
-            const index = coverageUpdateListeners.indexOf(listener);
-            if (index !== -1) {
-                coverageUpdateListeners.splice(index, 1);
-            }
-        }
-    };
-}
-/**
- * Notify all listeners of coverage update
- */
-function notifyCoverageListeners() {
-    if (cachedCoverage) {
-        for (const listener of coverageUpdateListeners) {
-            listener(cachedCoverage);
-        }
-    }
-}
-//# sourceMappingURL=coverageCalculator.js.map