norn-cli 2.3.0 → 2.4.0

package/out/coverageCalculator.js

@@ -0,0 +1,879 @@
+"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 assertion = extractStatusAssertInfo(line);
+        if (assertion) {
+            codes.push(assertion.code);
+        }
+    }
+    return codes;
+}
+function extractStatusAssertInfo(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 {
+            target: statusMatch[1],
+            code: statusMatch[2].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 { code: simpleMatch[1].toLowerCase() };
+    }
+    return null;
+}
+function extractStatusCodeFromAssert(line) {
+    return extractStatusAssertInfo(line)?.code ?? null;
+}
+function escapeRegex(value) {
+    return value.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+}
+function isVariableRedeclaration(line, varName) {
+    const trimmed = line.trim();
+    const pattern = new RegExp(`^var\\s+${escapeRegex(varName)}\\s*=`, 'i');
+    return pattern.test(trimmed);
+}
+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, assignedVar) {
+    const assertedCodes = [];
+    for (let j = startIndex + 1; j < lines.length; j++) {
+        const nextLine = lines[j].trim();
+        if (assignedVar) {
+            if (isVariableRedeclaration(nextLine, assignedVar)) {
+                break;
+            }
+            const assertion = extractStatusAssertInfo(nextLine);
+            if (assertion?.target?.toLowerCase() === assignedVar.toLowerCase()) {
+                assertedCodes.push(assertion.code);
+            }
+            continue;
+        }
+        // Stop at next request, sequence end, or other control flow
+        if (isCoverageScanBoundary(nextLine)) {
+            break;
+        }
+        const assertion = extractStatusAssertInfo(nextLine);
+        if (assertion) {
+            assertedCodes.push(assertion.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, assignedVar);
+            // 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) {
+                        if (namedRequest.endpointName) {
+                            calls.push({
+                                endpointName: namedRequest.endpointName,
+                                assertedCodes: assertedCodesAfterRun,
+                                assignedVar
+                            });
+                        }
+                        else if (namedRequest.url) {
+                            // 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, assignedVar);
+            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 either:
+ * - a raw URL/path/template target
+ * - a .nornapi endpoint name call such as GetPetById(1)
+ */
+function parseRequestContent(content) {
+    const lines = content.split('\n');
+    for (const line of lines) {
+        const trimmed = line.trim();
+        const match = trimmed.match(/^(GET|POST|PUT|DELETE|PATCH|HEAD|OPTIONS)\s+([^\s]+)/i);
+        if (match) {
+            const method = match[1].toUpperCase();
+            let target = match[2];
+            if ((target.startsWith('"') && target.endsWith('"')) ||
+                (target.startsWith("'") && target.endsWith("'"))) {
+                target = target.slice(1, -1);
+            }
+            const endpointMatch = target.match(/^([a-zA-Z_][a-zA-Z0-9_]*)(?:\(.*\))?$/);
+            if (endpointMatch) {
+                return { method, endpointName: endpointMatch[1] };
+            }
+            return { method, url: target };
+        }
+    }
+    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/path/template targets to the swagger endpoint path.
+                    try {
+                        const urlPath = extractSwaggerPath(urlCoverage.url, spec.baseUrl);
+                        // 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 {
+                        // Ignore malformed URLs/paths during coverage scan
+                    }
+                }
+            }
+            // 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