norn-cli 1.4.0 → 1.4.2

package/out/coverageCalculator.js

@@ -41,12 +41,15 @@ var __importStar = (this && this.__importStar) || (function () {
 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");
 /**
@@ -56,25 +59,25 @@ const nornapiParser_1 = require("./nornapiParser");
  * We need to strip the base URL (which typically includes version like /v2) to match swagger paths.
  */
 function extractSwaggerPath(fullUrl, swaggerBaseUrl) {
-    try {
-        // If it's already just a path (starts with /), return as-is
-        if (fullUrl.startsWith('/')) {
-            return fullUrl;
+    const normalizeWithBasePath = (rawPath) => {
+        let normalizedPath = rawPath || '/';
+        try {
+            normalizedPath = decodeURIComponent(normalizedPath);
+        }
+        catch {
+            // Keep original path if decoding fails
+        }
+        if (!normalizedPath.startsWith('/')) {
+            normalizedPath = `/${normalizedPath}`;
         }
-        const url = new URL(fullUrl);
-        // Decode the pathname to convert %7B to { and %7D to }
-        let path = decodeURIComponent(url.pathname);
-        // If we have a swagger base URL, try to strip it from the path
         if (swaggerBaseUrl) {
             try {
                 const baseUrl = new URL(swaggerBaseUrl);
                 const basePath = decodeURIComponent(baseUrl.pathname);
-                // If the path starts with the base path (e.g., /v2), strip it
-                if (basePath && basePath !== '/' && path.startsWith(basePath)) {
-                    path = path.substring(basePath.length);
-                    // Ensure path starts with /
-                    if (!path.startsWith('/')) {
-                        path = '/' + path;
+                if (basePath && basePath !== '/' && normalizedPath.startsWith(basePath)) {
+                    normalizedPath = normalizedPath.substring(basePath.length);
+                    if (!normalizedPath.startsWith('/')) {
+                        normalizedPath = '/' + normalizedPath;
                     }
                 }
             }
@@ -82,12 +85,47 @@ function extractSwaggerPath(fullUrl, swaggerBaseUrl) {
                 // Ignore base URL parsing errors
             }
         }
-        return path || '/';
+        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?:\/\/[^\/]+(\/.*)/);
-        return match ? match[1] : fullUrl;
+        if (match) {
+            return normalizeWithBasePath(match[1]);
+        }
+        return normalizeWithBasePath(fullUrl);
     }
 }
 /**
@@ -105,26 +143,65 @@ function extractAssertedStatusCodes(sequenceContent) {
     const codes = [];
     const lines = sequenceContent.split('\n');
     for (const line of lines) {
-        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) {
-            codes.push(statusMatch[1].toLowerCase());
-            continue;
-        }
-        // Also match simpler patterns like: assert status 200
-        const simpleMatch = trimmed.match(/^assert\s+status\s+(\d{3}|[1-5]xx)$/i);
-        if (simpleMatch) {
-            codes.push(simpleMatch[1].toLowerCase());
+        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"
@@ -196,9 +273,11 @@ function extractApiCalls(sequenceContent, allSequences, allNamedRequests, visite
     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);
+        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 targetName = runMatch[1];
+            const assignedVar = runMatch[1];
+            const targetName = runMatch[2];
+            const assertedCodesAfterRun = collectStatusAssertionsFollowingLine(lines, i);
             // Avoid infinite recursion
             if (!visitedSet.has(targetName)) {
                 visitedSet.add(targetName);
@@ -208,6 +287,15 @@ function extractApiCalls(sequenceContent, allSequences, allNamedRequests, visite
                     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;
                     }
@@ -216,30 +304,13 @@ function extractApiCalls(sequenceContent, allSequences, allNamedRequests, visite
                 if (allNamedRequests) {
                     const namedRequest = allNamedRequests.get(targetName);
                     if (namedRequest) {
-                        // Look for assert status lines following this run command
-                        const assertedCodes = [];
-                        for (let j = i + 1; j < lines.length; j++) {
-                            const nextLine = lines[j].trim();
-                            // Stop at next request, sequence end, or other control flow
-                            if (/^(?:var\s+[a-zA-Z_][a-zA-Z0-9_]*\s*=\s*)?(GET|POST|PUT|DELETE|PATCH|HEAD|OPTIONS)\s+/i.test(nextLine) ||
-                                /^end\s+sequence$/i.test(nextLine) ||
-                                /^run\s+/i.test(nextLine) ||
-                                /^if\s+/i.test(nextLine) ||
-                                /^foreach\s+/i.test(nextLine)) {
-                                break;
-                            }
-                            // Check for assert status
-                            const statusMatch = nextLine.match(/^assert\s+(?:(?:\$\d+|[a-zA-Z_][a-zA-Z0-9_]*)\.)?status\s*(?:==|>=|<=|>|<|!=)?\s*(\d{3}|[1-5]xx)$/i);
-                            if (statusMatch) {
-                                assertedCodes.push(statusMatch[1].toLowerCase());
-                            }
-                        }
                         // Add this as a URL-based API call (will be matched by URL later)
                         calls.push({
                             endpointName: `__url__${namedRequest.method}__${namedRequest.url}`,
-                            assertedCodes,
+                            assertedCodes: assertedCodesAfterRun,
                             method: namedRequest.method,
-                            url: namedRequest.url
+                            url: namedRequest.url,
+                            assignedVar
                         });
                         continue;
                     }
@@ -254,34 +325,12 @@ function extractApiCalls(sequenceContent, allSequences, allNamedRequests, visite
         // - 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);
+        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 endpointName = apiCallMatch[2];
-            // Look for assert status lines following this request (until next request or end)
-            const assertedCodes = [];
-            for (let j = i + 1; j < lines.length; j++) {
-                const nextLine = lines[j].trim();
-                // Stop at next request, sequence end, or other control flow
-                // Also stop if we see another var assignment with HTTP method
-                if (/^(?:var\s+[a-zA-Z_][a-zA-Z0-9_]*\s*=\s*)?(GET|POST|PUT|DELETE|PATCH|HEAD|OPTIONS)\s+/i.test(nextLine) ||
-                    /^end\s+sequence$/i.test(nextLine) ||
-                    /^run\s+/i.test(nextLine) ||
-                    /^if\s+/i.test(nextLine) ||
-                    /^foreach\s+/i.test(nextLine)) {
-                    break;
-                }
-                // Check for assert status with variable name or $N reference
-                const statusMatch = nextLine.match(/^assert\s+(?:(?:\$\d+|[a-zA-Z_][a-zA-Z0-9_]*)\.)?status\s*(?:==|>=|<=|>|<|!=)?\s*(\d{3}|[1-5]xx)$/i);
-                if (statusMatch) {
-                    assertedCodes.push(statusMatch[1].toLowerCase());
-                }
-                // Simpler pattern
-                const simpleMatch = nextLine.match(/^assert\s+status\s+(\d{3}|[1-5]xx)$/i);
-                if (simpleMatch) {
-                    assertedCodes.push(simpleMatch[1].toLowerCase());
-                }
-            }
-            calls.push({ endpointName, assertedCodes });
+            const assignedVar = apiCallMatch[1];
+            const endpointName = apiCallMatch[3];
+            const assertedCodes = collectStatusAssertionsFollowingLine(lines, i);
+            calls.push({ endpointName, assertedCodes, assignedVar });
         }
     }
     return calls;
@@ -399,11 +448,69 @@ function parseRequestContent(content) {
     }
     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) {
+async function calculateWorkspaceCoverage(useCachedSpecs = false, scopedNornapiFilePath) {
     const workspaceFolders = vscode.workspace.workspaceFolders;
     if (!workspaceFolders) {
         return {
@@ -415,7 +522,11 @@ async function calculateWorkspaceCoverage(useCachedSpecs = false) {
         };
     }
     // Step 1: Find all .nornapi files and extract swagger URLs + endpoint mappings
-    const nornapiFiles = await vscode.workspace.findFiles('**/*.nornapi', '**/node_modules/**');
+    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 = [];
@@ -466,64 +577,11 @@ async function calculateWorkspaceCoverage(useCachedSpecs = false) {
     knownSwaggerUrls = currentUrls;
     // Step 2: Find all .norn files and extract API calls with assert status
     const nornFiles = await vscode.workspace.findFiles('**/*.norn', '**/node_modules/**');
-    // Map: endpoint name -> list of asserted status codes (from all sequences)
-    const coverageByName = new Map();
-    // First pass: build a combined map of all sequences across all files
-    // This allows test sequences to call sub-sequences defined in other files
-    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);
-        }
-    }
-    // Track URL-based API calls separately (for matching by URL instead of endpoint name)
-    const coverageByUrl = new Map();
-    // Second pass: extract API calls from test sequences, following run commands
-    for (const file of nornFiles) {
-        try {
-            const content = fs.readFileSync(file.fsPath, 'utf-8');
-            const testSequences = extractTestSequences(content);
-            for (const sequence of testSequences) {
-                // Pass the map of all sequences and named requests so we can follow "run" calls
-                const apiCalls = extractApiCalls(sequence.content, allSequencesMap, allNamedRequestsMap);
-                for (const call of apiCalls) {
-                    // Check if this is a URL-based call (from a named request block)
-                    if (call.url && call.method) {
-                        const key = `${call.method} ${call.url}`;
-                        if (!coverageByUrl.has(key)) {
-                            coverageByUrl.set(key, { method: call.method, url: call.url, assertedCodes: new Set() });
-                        }
-                        for (const code of call.assertedCodes) {
-                            coverageByUrl.get(key).assertedCodes.add(code);
-                        }
-                    }
-                    else {
-                        // Regular endpoint name-based call
-                        if (!coverageByName.has(call.endpointName)) {
-                            coverageByName.set(call.endpointName, new Set());
-                        }
-                        for (const code of call.assertedCodes) {
-                            coverageByName.get(call.endpointName).add(code);
-                        }
-                    }
-                }
-            }
-        }
-        catch (error) {
-            console.error(`Error reading .norn file ${file.fsPath}:`, error);
-        }
+    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
@@ -555,7 +613,7 @@ async function calculateWorkspaceCoverage(useCachedSpecs = false) {
     }
     const specs = [];
     for (const [swaggerUrl, swaggerSpec] of swaggerSpecs) {
-        const coverageResult = calculateCoverageForSpec(swaggerUrl, swaggerSpec, endpointMappings.filter(m => m.swaggerUrl === swaggerUrl), coverageByName, coverageByUrl);
+        const coverageResult = calculateCoverageForSpec(swaggerUrl, swaggerSpec, endpointMappings.filter(m => m.swaggerUrl === swaggerUrl), scopedCoverageByRoot);
         specs.push(coverageResult);
     }
     // Step 4: Aggregate results
@@ -576,28 +634,32 @@ async function calculateWorkspaceCoverage(useCachedSpecs = false) {
 /**
  * Calculate coverage for a single swagger spec
  */
-function calculateCoverageForSpec(swaggerUrl, spec, endpointMappings, coverageByName, coverageByUrl) {
+function calculateCoverageForSpec(swaggerUrl, spec, endpointMappings, scopedCoverageByRoot) {
     const endpoints = [];
     let total = 0;
     let covered = 0;
-    // Build a lookup from swagger key to endpoint names
-    const keyToNames = new Map();
+    // Build a lookup from swagger key to mapped .nornapi endpoints (with source file context)
+    const keyToMappings = new Map();
     for (const mapping of endpointMappings) {
-        if (!keyToNames.has(mapping.swaggerKey)) {
-            keyToNames.set(mapping.swaggerKey, []);
+        if (!keyToMappings.has(mapping.swaggerKey)) {
+            keyToMappings.set(mapping.swaggerKey, []);
         }
-        keyToNames.get(mapping.swaggerKey).push(mapping.name);
+        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 names = keyToNames.get(swaggerKey) || [];
+            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
-            for (const name of names) {
-                const codes = coverageByName.get(name);
+            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);
@@ -607,8 +669,8 @@ function calculateCoverageForSpec(swaggerUrl, spec, endpointMappings, coverageBy
                                 if (!coveredByNames[responseCode]) {
                                     coveredByNames[responseCode] = [];
                                 }
-                                if (!coveredByNames[responseCode].includes(name)) {
-                                    coveredByNames[responseCode].push(name);
+                                if (!coveredByNames[responseCode].includes(mapping.name)) {
+                                    coveredByNames[responseCode].push(mapping.name);
                                 }
                             }
                         }
@@ -617,26 +679,32 @@ function calculateCoverageForSpec(swaggerUrl, spec, endpointMappings, coverageBy
             }
             // Also check URL-based coverage (from named request blocks)
             // Match URLs to swagger endpoints by comparing the path portion
-            for (const [, urlCoverage] of coverageByUrl) {
-                // Check if method matches
-                if (urlCoverage.method.toUpperCase() !== endpoint.method.toUpperCase()) {
+            for (const rootPath of endpointRootPaths) {
+                const scopedCoverage = scopedCoverageByRoot.get(rootPath);
+                if (!scopedCoverage) {
                     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);
+                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
+                    catch {
+                        // Invalid URL, skip
+                    }
                 }
             }
             // Calculate coverage for each response code
@@ -706,6 +774,13 @@ async function getCoverage() {
     }
     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
  */
@@ -714,6 +789,12 @@ async function refreshCoverage() {
     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

package/out/coveragePanel.js

@@ -42,14 +42,17 @@ class CoveragePanel {
     static currentPanel;
     _panel;
     _disposables = [];
-    constructor(panel) {
+    _scopeNornapiFilePath;
+    constructor(panel, scopeNornapiFilePath) {
         this._panel = panel;
+        this._scopeNornapiFilePath = scopeNornapiFilePath;
         this._panel.onDidDispose(() => this.dispose(), null, this._disposables);
     }
-    static show(coverage) {
+    static show(coverage, scopeNornapiFilePath) {
         const column = vscode.ViewColumn.Beside;
         if (CoveragePanel.currentPanel) {
             CoveragePanel.currentPanel._panel.reveal(column);
+            CoveragePanel.currentPanel._scopeNornapiFilePath = scopeNornapiFilePath;
             CoveragePanel.currentPanel._update(coverage);
             return;
         }
@@ -57,7 +60,7 @@ class CoveragePanel {
             enableScripts: true,
             retainContextWhenHidden: true,
         });
-        CoveragePanel.currentPanel = new CoveragePanel(panel);
+        CoveragePanel.currentPanel = new CoveragePanel(panel, scopeNornapiFilePath);
         CoveragePanel.currentPanel._update(coverage);
     }
     dispose() {
@@ -77,7 +80,7 @@ class CoveragePanel {
         this._panel.webview.onDidReceiveMessage(async (message) => {
             switch (message.type) {
                 case 'refresh':
-                    vscode.commands.executeCommand('norn.refreshCoverage');
+                    vscode.commands.executeCommand('norn.refreshCoverage', this._scopeNornapiFilePath);
                     break;
             }
         }, null, this._disposables);