norn-cli 1.4.0 → 1.4.2

package/out/diagnosticProvider.js

@@ -100,6 +100,46 @@ function stripInlineComment(line) {
     }
     return line;
 }
+function isHttpRequestStart(line) {
+    return /^(?:var\s+[a-zA-Z_][a-zA-Z0-9_]*\s*=\s*)?(GET|POST|PUT|DELETE|PATCH|HEAD|OPTIONS)\s+/i.test(line.trim());
+}
+function isRequestBodyBoundary(line) {
+    const trimmed = line.trim();
+    if (!trimmed) {
+        return false;
+    }
+    return isHttpRequestStart(trimmed) ||
+        /^\[/.test(trimmed) ||
+        /^(?:test\s+)?sequence\s+/i.test(trimmed) ||
+        /^end\s+sequence$/i.test(trimmed) ||
+        /^(?:var\s+[a-zA-Z_][a-zA-Z0-9_]*\s*=\s*)?run\s+/i.test(trimmed) ||
+        /^assert\s+/i.test(trimmed) ||
+        /^print\s+/i.test(trimmed) ||
+        /^if\s+/i.test(trimmed) ||
+        /^foreach\s+/i.test(trimmed) ||
+        /^return\s+/i.test(trimmed);
+}
+function countChar(value, char) {
+    let count = 0;
+    for (let i = 0; i < value.length; i++) {
+        if (value[i] === char) {
+            count++;
+        }
+    }
+    return count;
+}
+function looksLikeJsonPropertyLine(line) {
+    return /^"[^"\\]*(?:\\.[^"\\]*)*"\s*:\s*.+$/.test(line.trim());
+}
+function getHeaderValueCaseInsensitive(headers, headerName) {
+    const target = headerName.toLowerCase();
+    for (const [name, value] of Object.entries(headers)) {
+        if (name.toLowerCase() === target) {
+            return value;
+        }
+    }
+    return undefined;
+}
 /**
  * Tokenize print statement content into individual tokens.
  * Respects quoted strings and splits on operators/whitespace.
@@ -181,7 +221,7 @@ class DiagnosticProvider {
         const text = document.getText();
         // Extract file-level variables (outside sequences) + environment
         const fileLevelVariables = (0, parser_1.extractFileLevelVariables)(text);
-        const envVariables = (0, environmentProvider_1.getEnvironmentVariables)();
+        const envVariables = (0, environmentProvider_1.getEnvironmentVariables)(document.uri.fsPath);
         const globalVariables = { ...envVariables, ...fileLevelVariables };
         // Extract sequences for scope-aware checking
         const sequences = (0, sequenceRunner_1.extractSequences)(text);
@@ -341,7 +381,11 @@ class DiagnosticProvider {
                                 diagnostics.push(diagnostic);
                             }
                             else {
-                                importedHeaderGroups.set(group.name, { sourcePath: imp.path, lineNumber: imp.lineNumber });
+                                importedHeaderGroups.set(group.name, {
+                                    sourcePath: imp.path,
+                                    lineNumber: imp.lineNumber,
+                                    headerGroup: group
+                                });
                             }
                         }
                     }
@@ -585,6 +629,95 @@ class DiagnosticProvider {
                 }
             }
         }
+        // Check for JSON-like request body properties without surrounding { } object
+        const bodyMethods = new Set(['POST', 'PUT', 'PATCH']);
+        const requestStartRegex = /^\s*(?:var\s+[a-zA-Z_][a-zA-Z0-9_]*\s*=\s*)?(GET|POST|PUT|DELETE|PATCH|HEAD|OPTIONS)\s+/i;
+        const inlineHeaderRegex = /^([A-Za-z][A-Za-z0-9\-]*)\s*:\s*(.+)$/;
+        const formContentTypes = ['application/x-www-form-urlencoded', 'multipart/form-data'];
+        for (let i = 0; i < lines.length; i++) {
+            const line = lines[i];
+            if (isCommentLine(line)) {
+                continue;
+            }
+            const lineWithoutComment = stripInlineComment(line).trim();
+            const requestMatch = lineWithoutComment.match(requestStartRegex);
+            if (!requestMatch) {
+                continue;
+            }
+            const method = requestMatch[1].toUpperCase();
+            if (!bodyMethods.has(method)) {
+                continue;
+            }
+            let requestContentType;
+            const afterMethod = lineWithoutComment.replace(requestStartRegex, '').trim();
+            const methodLineTokens = afterMethod.split(/\s+/).filter(t => t.length > 0);
+            for (const token of methodLineTokens) {
+                const cleanToken = token.replace(/[,)]+$/g, '');
+                const group = importedHeaderGroups.get(cleanToken)?.headerGroup;
+                if (group) {
+                    const headerValue = getHeaderValueCaseInsensitive(group.headers, 'Content-Type');
+                    if (headerValue) {
+                        requestContentType = headerValue.toLowerCase();
+                    }
+                }
+            }
+            let objectDepth = 0;
+            let hasReported = false;
+            let reachedBody = false;
+            for (let j = i + 1; j < lines.length; j++) {
+                const bodyLine = lines[j];
+                if (isCommentLine(bodyLine)) {
+                    continue;
+                }
+                const bodyLineWithoutComment = stripInlineComment(bodyLine);
+                const trimmedBodyLine = bodyLineWithoutComment.trim();
+                if (!trimmedBodyLine) {
+                    continue;
+                }
+                if (isRequestBodyBoundary(trimmedBodyLine)) {
+                    break;
+                }
+                if (!reachedBody) {
+                    const headerMatch = trimmedBodyLine.match(inlineHeaderRegex);
+                    if (headerMatch) {
+                        if (headerMatch[1].toLowerCase() === 'content-type') {
+                            requestContentType = headerMatch[2].trim().toLowerCase();
+                        }
+                        continue;
+                    }
+                    const headerGroup = importedHeaderGroups.get(trimmedBodyLine)?.headerGroup;
+                    if (headerGroup) {
+                        const headerValue = getHeaderValueCaseInsensitive(headerGroup.headers, 'Content-Type');
+                        if (headerValue) {
+                            requestContentType = headerValue.toLowerCase();
+                        }
+                        continue;
+                    }
+                }
+                reachedBody = true;
+                const isFormBody = requestContentType
+                    ? formContentTypes.some(ct => requestContentType.includes(ct))
+                    : false;
+                if (isFormBody) {
+                    continue;
+                }
+                const startsJsonObject = trimmedBodyLine.startsWith('{');
+                if (!hasReported && looksLikeJsonPropertyLine(trimmedBodyLine) && objectDepth === 0 && !startsJsonObject) {
+                    const startCol = bodyLine.indexOf('"');
+                    const range = new vscode.Range(new vscode.Position(j, startCol >= 0 ? startCol : 0), new vscode.Position(j, bodyLine.length));
+                    const diagnostic = new vscode.Diagnostic(range, `Invalid JSON body: properties must be wrapped in '{' and '}'.`, vscode.DiagnosticSeverity.Error);
+                    diagnostic.source = 'Norn';
+                    diagnostic.code = 'invalid-json-body-missing-braces';
+                    diagnostics.push(diagnostic);
+                    hasReported = true;
+                }
+                objectDepth += countChar(trimmedBodyLine, '{');
+                objectDepth -= countChar(trimmedBodyLine, '}');
+                if (objectDepth < 0) {
+                    objectDepth = 0;
+                }
+            }
+        }
         // Find empty variable references {{}} or {{ }}
         const emptyVarRegex = /\{\{\s*\}\}/g;
         let emptyMatch;

package/out/environmentProvider.js

@@ -42,9 +42,11 @@ exports.setActiveEnvironment = setActiveEnvironment;
 exports.getEnvironmentVariables = getEnvironmentVariables;
 exports.getAvailableEnvironments = getAvailableEnvironments;
 exports.createStatusBarItem = createStatusBarItem;
+exports.refreshEnvironmentStatusBar = refreshEnvironmentStatusBar;
 exports.showEnvironmentPicker = showEnvironmentPicker;
 exports.disposeStatusBar = disposeStatusBar;
 exports.createCoverageStatusBarItem = createCoverageStatusBarItem;
+exports.refreshCoverageStatusBarContext = refreshCoverageStatusBarContext;
 exports.updateCoverageStatusBar = updateCoverageStatusBar;
 exports.getCoverageStatusBarItem = getCoverageStatusBarItem;
 const vscode = __importStar(require("vscode"));
@@ -55,6 +57,39 @@ const ENV_FILENAME = '.nornenv';
 let activeEnvironment;
 let statusBarItem;
 let coverageStatusBarItem;
+let hasCoverageData = false;
+/**
+ * Resolves where environment file discovery should start.
+ * If the path points to a directory, search from that directory.
+ * If it points to a file (or non-existent path), search from the parent directory.
+ */
+function getEnvSearchStartDirectory(targetPath) {
+    const resolvedPath = path.resolve(targetPath);
+    try {
+        const stats = fs.statSync(resolvedPath);
+        return stats.isDirectory() ? resolvedPath : path.dirname(resolvedPath);
+    }
+    catch {
+        return path.dirname(resolvedPath);
+    }
+}
+function getContextEnvFile() {
+    const activeEditor = vscode.window.activeTextEditor;
+    if (activeEditor && activeEditor.document.uri.scheme === 'file') {
+        return findEnvFileFromPath(activeEditor.document.uri.fsPath);
+    }
+    return findEnvFile();
+}
+function resolveEnvFilePath(pathOrSourceFile) {
+    if (!pathOrSourceFile) {
+        return getContextEnvFile();
+    }
+    const resolvedPath = path.resolve(pathOrSourceFile);
+    if (path.basename(resolvedPath) === ENV_FILENAME && fs.existsSync(resolvedPath)) {
+        return resolvedPath;
+    }
+    return findEnvFileFromPath(resolvedPath);
+}
 /**
  * Finds the .nornenv file in the workspace
  */
@@ -75,14 +110,17 @@ function findEnvFile() {
  * Finds .nornenv file relative to a specific file path (for CLI usage)
  */
 function findEnvFileFromPath(filePath) {
-    let dir = path.dirname(filePath);
-    const root = path.parse(dir).root;
-    while (dir !== root) {
+    let dir = getEnvSearchStartDirectory(filePath);
+    while (true) {
         const envPath = path.join(dir, ENV_FILENAME);
         if (fs.existsSync(envPath)) {
             return envPath;
         }
-        dir = path.dirname(dir);
+        const parentDir = path.dirname(dir);
+        if (parentDir === dir) {
+            break;
+        }
+        dir = parentDir;
     }
     return undefined;
 }
@@ -150,10 +188,14 @@ function parseEnvFile(content) {
     return config;
 }
 /**
- * Reads and parses the .nornenv file
+ * Reads and parses the resolved .nornenv file.
+ * Accepts either:
+ * - a path to a .nornenv file, or
+ * - a source file/directory path (it will resolve nearest .nornenv), or
+ * - undefined (uses current editor context/workspace fallback).
  */
-function loadEnvironmentConfig(envFilePath) {
-    const filePath = envFilePath || findEnvFile();
+function loadEnvironmentConfig(pathOrSourceFile) {
+    const filePath = resolveEnvFilePath(pathOrSourceFile);
     if (!filePath || !fs.existsSync(filePath)) {
         return undefined;
     }
@@ -181,8 +223,8 @@ function setActiveEnvironment(envName) {
 /**
  * Gets all variables for the current environment (common + environment-specific)
  */
-function getEnvironmentVariables(envFilePath) {
-    const config = loadEnvironmentConfig(envFilePath);
+function getEnvironmentVariables(pathOrSourceFile) {
+    const config = loadEnvironmentConfig(pathOrSourceFile);
     if (!config) {
         return {};
     }
@@ -200,8 +242,8 @@ function getEnvironmentVariables(envFilePath) {
 /**
  * Gets available environment names
  */
-function getAvailableEnvironments(envFilePath) {
-    const config = loadEnvironmentConfig(envFilePath);
+function getAvailableEnvironments(pathOrSourceFile) {
+    const config = loadEnvironmentConfig(pathOrSourceFile);
     if (!config) {
         return [];
     }
@@ -217,6 +259,12 @@ function createStatusBarItem() {
     statusBarItem.show();
     return statusBarItem;
 }
+/**
+ * Refreshes the status bar text based on current editor context.
+ */
+function refreshEnvironmentStatusBar() {
+    updateStatusBar();
+}
 /**
  * Updates the status bar item text
  */
@@ -224,7 +272,7 @@ function updateStatusBar() {
     if (!statusBarItem) {
         return;
     }
-    const envFile = findEnvFile();
+    const envFile = getContextEnvFile();
     if (!envFile) {
         statusBarItem.text = '$(globe) Norn: No Env';
         statusBarItem.tooltip = 'No .nornenv file found';
@@ -243,7 +291,8 @@ function updateStatusBar() {
  * Shows the environment picker
  */
 async function showEnvironmentPicker() {
-    const environments = getAvailableEnvironments();
+    const envFilePath = getContextEnvFile();
+    const environments = getAvailableEnvironments(envFilePath);
     if (environments.length === 0) {
         const createFile = await vscode.window.showInformationMessage('No .nornenv file found. Would you like to create one?', 'Create .nornenv', 'Cancel');
         if (createFile === 'Create .nornenv') {
@@ -338,6 +387,34 @@ function createCoverageStatusBarItem() {
     coverageStatusBarItem.hide(); // Hidden until we know there's swagger
     return coverageStatusBarItem;
 }
+function getActiveNornapiPath() {
+    const activeEditor = vscode.window.activeTextEditor;
+    if (!activeEditor) {
+        return undefined;
+    }
+    return activeEditor.document.languageId === 'nornapi'
+        ? activeEditor.document.uri.fsPath
+        : undefined;
+}
+/**
+ * Refresh coverage status bar command context for the current active editor.
+ */
+function refreshCoverageStatusBarContext() {
+    if (!coverageStatusBarItem || !hasCoverageData) {
+        return;
+    }
+    const activeNornapiPath = getActiveNornapiPath();
+    coverageStatusBarItem.command = {
+        command: 'norn.showCoverage',
+        title: 'Show Coverage',
+        arguments: activeNornapiPath ? [activeNornapiPath] : []
+    };
+    coverageStatusBarItem.text = '$(graph) Coverage';
+    coverageStatusBarItem.tooltip = activeNornapiPath
+        ? 'Show API coverage for this .nornapi file (includes this folder and subfolders only).'
+        : 'Show API coverage';
+    coverageStatusBarItem.show();
+}
 /**
  * Updates the coverage status bar display
  */
@@ -346,23 +423,15 @@ function updateCoverageStatusBar(hasSwagger, percentage, total, covered) {
         return;
     }
     if (!hasSwagger) {
+        hasCoverageData = false;
         coverageStatusBarItem.hide();
         return;
     }
-    // Choose icon based on coverage level
-    let icon = '$(graph)';
-    if (percentage >= 80) {
-        icon = '$(pass)';
-    }
-    else if (percentage >= 50) {
-        icon = '$(warning)';
-    }
-    else if (percentage > 0) {
-        icon = '$(error)';
-    }
-    coverageStatusBarItem.text = `${icon} ${percentage}%`;
-    coverageStatusBarItem.tooltip = `API Coverage: ${covered}/${total} response codes tested\nClick to view details`;
-    coverageStatusBarItem.show();
+    hasCoverageData = true;
+    void percentage;
+    void total;
+    void covered;
+    refreshCoverageStatusBarContext();
 }
 /**
  * Get the coverage status bar item (for external updates)

package/out/extension.js

@@ -57,6 +57,8 @@ const compareContentProvider_1 = require("./compareContentProvider");
 const contractDecorationProvider_1 = require("./contractDecorationProvider");
 const validationCache_1 = require("./validationCache");
 const schemaGenerator_1 = require("./schemaGenerator");
+const swaggerBodyIntellisenseCache_1 = require("./swaggerBodyIntellisenseCache");
+const chatParticipant_1 = require("./chatParticipant");
 // Module-level reference to contract decoration provider for refreshing after sequence runs
 let contractDecorationProviderInstance;
 function activate(context) {
@@ -66,6 +68,8 @@ function activate(context) {
     // Register Test Explorer integration
     const testController = new testProvider_1.NornTestController();
     context.subscriptions.push(testController);
+    // Register @norn Copilot Chat participant (gracefully skipped if Copilot is not installed)
+    (0, chatParticipant_1.registerChatParticipant)(context);
     const sendRequestCommand = vscode.commands.registerCommand('norn.sendRequest', (lineFromCodeLens) => processEditorsInput(context.extensionUri, lineFromCodeLens));
     const runSequenceCommand = vscode.commands.registerCommand('norn.runSequence', (lineFromCodeLens) => processSequence(context.extensionUri, lineFromCodeLens));
     const clearCookiesCommand = vscode.commands.registerCommand('norn.clearCookies', async () => {
@@ -187,6 +191,15 @@ var debug = false
                 if (baseUrlInput === undefined) {
                     return;
                 }
+                // Cache request body schemas for IntelliSense (best effort)
+                try {
+                    progress.report({ message: 'Caching request body schemas...' });
+                    const requestSchemas = await (0, swaggerParser_1.extractRequestBodySchemas)(swaggerUrl);
+                    (0, swaggerBodyIntellisenseCache_1.saveRequestBodySchemasForUrl)(swaggerUrl, baseUrlInput || spec.baseUrl, requestSchemas);
+                }
+                catch {
+                    // Keep endpoint import successful even if schema caching fails
+                }
                 // Generate the content
                 const content = (0, swaggerParser_1.generateNornapiContent)(spec, sectionNames, baseUrlInput || undefined);
                 // Find position to insert - after the swagger line
@@ -296,10 +309,12 @@ var debug = false
     // Create coverage status bar item
     const coverageStatusBarItem = (0, environmentProvider_1.createCoverageStatusBarItem)();
     // Register command to show coverage panel
-    const showCoverageCommand = vscode.commands.registerCommand('norn.showCoverage', async () => {
+    const showCoverageCommand = vscode.commands.registerCommand('norn.showCoverage', async (nornapiFilePath) => {
         try {
-            const coverage = await (0, coverageCalculator_1.getCoverage)();
-            coveragePanel_1.CoveragePanel.show(coverage);
+            const coverage = nornapiFilePath
+                ? await (0, coverageCalculator_1.getCoverageForNornapiFile)(nornapiFilePath)
+                : await (0, coverageCalculator_1.getCoverage)();
+            coveragePanel_1.CoveragePanel.show(coverage, nornapiFilePath);
         }
         catch (error) {
             const errorMessage = error instanceof Error ? error.message : String(error);
@@ -307,10 +322,12 @@ var debug = false
         }
     });
     // Register command to refresh coverage
-    const refreshCoverageCommand = vscode.commands.registerCommand('norn.refreshCoverage', async () => {
+    const refreshCoverageCommand = vscode.commands.registerCommand('norn.refreshCoverage', async (nornapiFilePath) => {
         try {
             (0, swaggerParser_1.invalidateSwaggerCache)();
-            const coverage = await (0, coverageCalculator_1.refreshCoverage)();
+            const coverage = nornapiFilePath
+                ? await (0, coverageCalculator_1.refreshCoverageForNornapiFile)(nornapiFilePath)
+                : await (0, coverageCalculator_1.refreshCoverage)();
             coveragePanel_1.CoveragePanel.updateContent(coverage);
             vscode.window.showInformationMessage(`Coverage refreshed: ${coverage.percentage}%`);
         }
@@ -319,6 +336,39 @@ var debug = false
             vscode.window.showErrorMessage(`Failed to refresh coverage: ${errorMessage}`);
         }
     });
+    const refreshSwaggerBodySchemasFromUrls = async (urls) => {
+        for (const swaggerUrl of urls) {
+            try {
+                const spec = await (0, swaggerParser_1.parseSwaggerSpec)(swaggerUrl);
+                const requestSchemas = await (0, swaggerParser_1.extractRequestBodySchemas)(swaggerUrl);
+                (0, swaggerBodyIntellisenseCache_1.saveRequestBodySchemasForUrl)(swaggerUrl, spec.baseUrl, requestSchemas);
+            }
+            catch {
+                // Best effort cache refresh for IntelliSense
+            }
+        }
+    };
+    const warmSwaggerBodySchemaCacheFromWorkspace = async () => {
+        try {
+            const nornapiFiles = await vscode.workspace.findFiles('**/*.nornapi', '**/node_modules/**');
+            const urls = new Set();
+            for (const file of nornapiFiles) {
+                try {
+                    const content = fsSync.readFileSync(file.fsPath, 'utf-8');
+                    for (const url of extractSwaggerUrlsFromNornapi(content)) {
+                        urls.add(url);
+                    }
+                }
+                catch {
+                    // Ignore individual file read errors
+                }
+            }
+            await refreshSwaggerBodySchemasFromUrls(Array.from(urls));
+        }
+        catch {
+            // Ignore workspace scan failures
+        }
+    };
     // Listen for coverage updates to update status bar and CodeLens
     const coverageUpdateListener = (0, coverageCalculator_1.onCoverageUpdate)((coverage) => {
         (0, environmentProvider_1.updateCoverageStatusBar)(coverage.hasSwagger, coverage.percentage, coverage.total, coverage.covered);
@@ -355,6 +405,12 @@ var debug = false
         if (document.languageId === 'norn' || document.languageId === 'nornapi') {
             scheduleCoverageUpdate();
         }
+        if (document.languageId === 'nornapi') {
+            const swaggerUrls = extractSwaggerUrlsFromNornapi(document.getText());
+            if (swaggerUrls.length > 0) {
+                void refreshSwaggerBodySchemasFromUrls(swaggerUrls);
+            }
+        }
     });
     // Initial coverage calculation (delayed to not slow down activation)
     setTimeout(async () => {
@@ -365,6 +421,10 @@ var debug = false
             // Ignore errors in initial coverage calculation
         }
     }, 2000);
+    // Warm Swagger request-body cache in background for IntelliSense.
+    setTimeout(() => {
+        void warmSwaggerBodySchemaCacheFromWorkspace();
+    }, 2500);
     // Create status bar item for environment
     const statusBarItem = (0, environmentProvider_1.createStatusBarItem)();
     // Register the CodeLens provider for .norn and .nornapi files
@@ -456,7 +516,7 @@ var debug = false
             }
             // Get variables and run imports
             const fileLevelVariables = (0, parser_1.extractFileLevelVariables)(fullText);
-            const envVars = (0, environmentProvider_1.getEnvironmentVariables)();
+            const envVars = (0, environmentProvider_1.getEnvironmentVariables)(activeEditor.document.uri.fsPath);
             const allVariables = { ...envVars, ...fileLevelVariables };
             const importResult = await (0, parser_1.resolveImports)(fullText, workingDir, async (filePath) => {
                 const content = await fs.readFile(filePath, 'utf-8');
@@ -528,8 +588,17 @@ var debug = false
     const onDidOpenDocument = vscode.workspace.onDidOpenTextDocument((document) => {
         if (document.languageId === 'norn' || document.languageId === 'nornenv' || document.languageId === 'nornapi') {
             diagnosticProvider.updateDiagnostics(document);
+            (0, environmentProvider_1.refreshEnvironmentStatusBar)();
+            (0, environmentProvider_1.refreshCoverageStatusBarContext)();
+            vscode.commands.executeCommand('norn.refreshCodeLenses');
         }
     });
+    // Refresh environment context when switching active editors
+    const onDidChangeActiveEditor = vscode.window.onDidChangeActiveTextEditor(() => {
+        (0, environmentProvider_1.refreshEnvironmentStatusBar)();
+        (0, environmentProvider_1.refreshCoverageStatusBarContext)();
+        vscode.commands.executeCommand('norn.refreshCodeLenses');
+    });
     // Clear diagnostics when document closes
     const onDidCloseDocument = vscode.workspace.onDidCloseTextDocument((document) => {
         diagnosticProvider.clearDiagnostics(document);
@@ -540,7 +609,7 @@ var debug = false
             diagnosticProvider.updateDiagnostics(document);
         }
     });
-    context.subscriptions.push(sendRequestCommand, runSequenceCommand, clearCookiesCommand, showCookiesCommand, selectEnvironmentCommand, selectEnvironmentAndRefreshCommand, createEnvFileCommand, importSwaggerCommand, generateSchemasFromSwaggerCommand, refreshDiagnosticsCommand, openContractViewCommand, openSchemaFileCommand, validateSchemaAssertionNowCommand, viewContractReportCommand, contractDecorationProvider, contractHoverProvider, showCoverageCommand, refreshCoverageCommand, coverageUpdateListener, statusBarItem, coverageStatusBarItem, codeLensProvider, completionProvider, diagnosticProvider, onDidChangeDocument, onDidOpenDocument, onDidCloseDocument, nornapiFileWatcher, documentSaveWatcher, { dispose: environmentProvider_1.disposeStatusBar });
+    context.subscriptions.push(sendRequestCommand, runSequenceCommand, clearCookiesCommand, showCookiesCommand, selectEnvironmentCommand, selectEnvironmentAndRefreshCommand, createEnvFileCommand, importSwaggerCommand, generateSchemasFromSwaggerCommand, refreshDiagnosticsCommand, openContractViewCommand, openSchemaFileCommand, validateSchemaAssertionNowCommand, viewContractReportCommand, contractDecorationProvider, contractHoverProvider, showCoverageCommand, refreshCoverageCommand, coverageUpdateListener, statusBarItem, coverageStatusBarItem, codeLensProvider, completionProvider, diagnosticProvider, onDidChangeDocument, onDidOpenDocument, onDidChangeActiveEditor, onDidCloseDocument, nornapiFileWatcher, documentSaveWatcher, { dispose: environmentProvider_1.disposeStatusBar });
 }
 function formatSequenceCaseLabel(caseParams, index) {
     const entries = Object.entries(caseParams);
@@ -623,7 +692,7 @@ async function processSequence(extensionUri, lineFromCodeLens) {
     }
     // Merge environment variables with file-level variables (outside sequences)
     // Variables inside sequences are local to that sequence
-    const envVariables = (0, environmentProvider_1.getEnvironmentVariables)();
+    const envVariables = (0, environmentProvider_1.getEnvironmentVariables)(editor.document.uri.fsPath);
     const fileVariables = (0, parser_1.extractFileLevelVariables)(fullText);
     const allVariables = { ...envVariables, ...fileVariables };
     // Apply default parameter values for sequences with all-optional parameters
@@ -831,7 +900,7 @@ async function processEditorsInput(extensionUri, lineFromCodeLens) {
     const workingDir = path.dirname(editor.document.uri.fsPath);
     try {
         // Extract variables: environment + file (file takes precedence)
-        const envVariables = (0, environmentProvider_1.getEnvironmentVariables)();
+        const envVariables = (0, environmentProvider_1.getEnvironmentVariables)(editor.document.uri.fsPath);
         const fileVariables = (0, parser_1.extractVariables)(fullText);
         const variables = { ...envVariables, ...fileVariables };
         // Resolve imports to get API definitions (endpoints and header groups)
@@ -1017,6 +1086,26 @@ function debounce(fn, delay) {
         }, delay);
     });
 }
+function extractSwaggerUrlsFromNornapi(content) {
+    const urls = new Set();
+    const lines = content.split('\n');
+    for (const line of lines) {
+        const trimmed = line.trim();
+        if (!trimmed || trimmed.startsWith('#')) {
+            continue;
+        }
+        const quotedMatch = trimmed.match(/^swagger\s+["']([^"']+)["']\s*$/i);
+        if (quotedMatch) {
+            urls.add(quotedMatch[1]);
+            continue;
+        }
+        const unquotedMatch = trimmed.match(/^swagger\s+(https?:\/\/\S+)\s*$/i);
+        if (unquotedMatch) {
+            urls.add(unquotedMatch[1]);
+        }
+    }
+    return Array.from(urls);
+}
 function deactivate() {
     // Clear caches on deactivation
     (0, swaggerParser_1.clearSwaggerCache)();