norn-cli 1.6.0 → 1.6.2

package/out/extension.js

@@ -1,1114 +0,0 @@
-"use strict";
-var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    var desc = Object.getOwnPropertyDescriptor(m, k);
-    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
-      desc = { enumerable: true, get: function() { return m[k]; } };
-    }
-    Object.defineProperty(o, k2, desc);
-}) : (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    o[k2] = m[k];
-}));
-var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
-    Object.defineProperty(o, "default", { enumerable: true, value: v });
-}) : function(o, v) {
-    o["default"] = v;
-});
-var __importStar = (this && this.__importStar) || (function () {
-    var ownKeys = function(o) {
-        ownKeys = Object.getOwnPropertyNames || function (o) {
-            var ar = [];
-            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
-            return ar;
-        };
-        return ownKeys(o);
-    };
-    return function (mod) {
-        if (mod && mod.__esModule) return mod;
-        var result = {};
-        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
-        __setModuleDefault(result, mod);
-        return result;
-    };
-})();
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.activate = activate;
-exports.saveSchemaValidationResults = saveSchemaValidationResults;
-exports.deactivate = deactivate;
-const vscode = __importStar(require("vscode"));
-const path = __importStar(require("path"));
-const fs = __importStar(require("fs/promises"));
-const fsSync = __importStar(require("fs"));
-const parser_1 = require("./parser");
-const httpClient_1 = require("./httpClient");
-const codeLensProvider_1 = require("./codeLensProvider");
-const completionProvider_1 = require("./completionProvider");
-const responsePanel_1 = require("./responsePanel");
-const diagnosticProvider_1 = require("./diagnosticProvider");
-const sequenceRunner_1 = require("./sequenceRunner");
-const environmentProvider_1 = require("./environmentProvider");
-const swaggerParser_1 = require("./swaggerParser");
-const nornapiParser_1 = require("./nornapiParser");
-const testProvider_1 = require("./testProvider");
-const coverageCalculator_1 = require("./coverageCalculator");
-const coveragePanel_1 = require("./coveragePanel");
-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) {
-    console.log('Norn extension activated');
-    // Register content provider for response comparison diff
-    (0, compareContentProvider_1.registerCompareContentProvider)(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 () => {
-        (0, httpClient_1.clearCookies)();
-        vscode.window.showInformationMessage('Norn: All cookies cleared');
-    });
-    const showCookiesCommand = vscode.commands.registerCommand('norn.showCookies', async () => {
-        const cookies = await (0, httpClient_1.getAllCookies)();
-        if (cookies.length === 0) {
-            vscode.window.showInformationMessage('Norn: No cookies stored');
-        }
-        else {
-            const items = cookies.map(c => `${c.domain}: ${c.name}=${c.value.substring(0, 30)}${c.value.length > 30 ? '...' : ''}`);
-            vscode.window.showQuickPick(items, { title: 'Stored Cookies', canPickMany: false });
-        }
-    });
-    // Register environment selector command
-    const selectEnvironmentCommand = vscode.commands.registerCommand('norn.selectEnvironment', async () => {
-        await (0, environmentProvider_1.showEnvironmentPicker)();
-        vscode.commands.executeCommand('norn.refreshDiagnostics');
-    });
-    // Register environment selector with refresh (for CodeLens)
-    const selectEnvironmentAndRefreshCommand = vscode.commands.registerCommand('norn.selectEnvironmentAndRefresh', async () => {
-        await (0, environmentProvider_1.showEnvironmentPicker)();
-        vscode.commands.executeCommand('norn.refreshCodeLenses');
-        vscode.commands.executeCommand('norn.refreshDiagnostics');
-    });
-    // Register command to create .nornenv file
-    const createEnvFileCommand = vscode.commands.registerCommand('norn.createEnvFile', async () => {
-        const workspaceFolders = vscode.workspace.workspaceFolders;
-        if (!workspaceFolders) {
-            vscode.window.showErrorMessage('No workspace folder open');
-            return;
-        }
-        // If multiple folders, ask which one
-        let targetFolder = workspaceFolders[0];
-        if (workspaceFolders.length > 1) {
-            const picked = await vscode.window.showWorkspaceFolderPick({
-                placeHolder: 'Select workspace folder for .nornenv file'
-            });
-            if (!picked) {
-                return;
-            }
-            targetFolder = picked;
-        }
-        const envFilePath = vscode.Uri.joinPath(targetFolder.uri, '.nornenv');
-        const template = `# Norn Environment Configuration
-# Variables defined here are available in your .norn files as {{variableName}}
-
-# Common variables (available in all environments)
-var baseUrl = https://api.example.com
-
-# Development environment
-[env:dev]
-var apiKey = dev-api-key-here
-var debug = true
-
-# Production environment  
-[env:prod]
-var apiKey = prod-api-key-here
-var debug = false
-`;
-        try {
-            await vscode.workspace.fs.writeFile(envFilePath, Buffer.from(template, 'utf8'));
-            const doc = await vscode.workspace.openTextDocument(envFilePath);
-            await vscode.window.showTextDocument(doc);
-            vscode.commands.executeCommand('norn.refreshCodeLenses');
-            vscode.window.showInformationMessage('Created .nornenv file. Select an environment from the status bar.');
-        }
-        catch (error) {
-            vscode.window.showErrorMessage(`Failed to create .nornenv: ${error}`);
-        }
-    });
-    // Register command to import endpoints from Swagger/OpenAPI spec
-    const importSwaggerCommand = vscode.commands.registerCommand('norn.importSwagger', async (swaggerUrl, lineNumber) => {
-        const editor = vscode.window.activeTextEditor;
-        if (!editor) {
-            vscode.window.showErrorMessage('No active editor');
-            return;
-        }
-        try {
-            // Show progress while fetching
-            await vscode.window.withProgress({
-                location: vscode.ProgressLocation.Notification,
-                title: 'Parsing OpenAPI spec...',
-                cancellable: false
-            }, async (progress) => {
-                progress.report({ message: 'Fetching specification...' });
-                // Parse the swagger spec
-                const spec = await (0, swaggerParser_1.parseSwaggerSpec)(swaggerUrl);
-                progress.report({ message: 'Spec loaded!' });
-                // Build QuickPick items for sections
-                const sectionItems = [
-                    { label: 'All', description: `Import all ${spec.sections.reduce((acc, s) => acc + s.endpoints.length, 0)} endpoints`, picked: true }
-                ];
-                for (const section of spec.sections) {
-                    sectionItems.push({
-                        label: section.name,
-                        description: section.description || `${section.endpoints.length} endpoints`
-                    });
-                }
-                // Show section picker
-                const selectedSections = await vscode.window.showQuickPick(sectionItems, {
-                    canPickMany: true,
-                    placeHolder: `Select sections to import from ${spec.title}`,
-                    title: 'Import OpenAPI Endpoints'
-                });
-                if (!selectedSections || selectedSections.length === 0) {
-                    return;
-                }
-                const sectionNames = selectedSections.map(s => s.label);
-                // Ask for custom baseUrl
-                const baseUrlInput = await vscode.window.showInputBox({
-                    prompt: 'Enter custom base URL (or leave empty to use spec default)',
-                    placeHolder: spec.baseUrl || 'https://api.example.com',
-                    value: spec.baseUrl
-                });
-                // User cancelled
-                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
-                const document = editor.document;
-                const swaggerLine = document.lineAt(lineNumber);
-                const insertPosition = new vscode.Position(lineNumber + 1, 0);
-                // Insert the generated content
-                await editor.edit(editBuilder => {
-                    editBuilder.insert(insertPosition, '\n' + content + '\n');
-                });
-                vscode.window.showInformationMessage(`Imported ${sectionNames.includes('All') ? 'all sections' : sectionNames.join(', ')} from ${spec.title}`);
-            });
-        }
-        catch (error) {
-            const errorMessage = error instanceof Error ? error.message : String(error);
-            vscode.window.showErrorMessage(`Failed to parse OpenAPI spec: ${errorMessage}`);
-        }
-    });
-    // Register command to generate JSON Schemas from Swagger/OpenAPI spec
-    const generateSchemasFromSwaggerCommand = vscode.commands.registerCommand('norn.generateSchemasFromSwagger', async (swaggerUrl, sourceFile) => {
-        try {
-            const schemas = await vscode.window.withProgress({
-                location: vscode.ProgressLocation.Notification,
-                title: 'Extracting schemas from OpenAPI spec...',
-                cancellable: false
-            }, async (progress) => {
-                progress.report({ message: 'Fetching specification...' });
-                return await (0, swaggerParser_1.extractResponseSchemas)(swaggerUrl);
-            });
-            if (schemas.length === 0) {
-                vscode.window.showWarningMessage('No response schemas found in the OpenAPI spec');
-                return;
-            }
-            // Ask user for output folder
-            const workspaceRoot = vscode.workspace.workspaceFolders?.[0]?.uri.fsPath;
-            const defaultFolder = workspaceRoot ? path.join(workspaceRoot, 'contracts') : path.dirname(sourceFile);
-            const folderItems = [
-                { label: 'contracts/', description: `${defaultFolder}`, picked: true },
-                { label: 'schemas/', description: path.join(path.dirname(sourceFile), 'schemas') },
-                { label: 'Choose folder...', description: 'Select a custom folder' }
-            ];
-            const selectedFolder = await vscode.window.showQuickPick(folderItems, {
-                placeHolder: 'Select output folder for schema files',
-                title: `Generate ${schemas.length} Schemas`
-            });
-            if (!selectedFolder) {
-                return;
-            }
-            let outputFolder;
-            if (selectedFolder.label === 'Choose folder...') {
-                const folderUri = await vscode.window.showOpenDialog({
-                    canSelectFiles: false,
-                    canSelectFolders: true,
-                    canSelectMany: false,
-                    title: 'Select output folder for schemas'
-                });
-                if (!folderUri || folderUri.length === 0) {
-                    return;
-                }
-                outputFolder = folderUri[0].fsPath;
-            }
-            else if (selectedFolder.label === 'contracts/') {
-                outputFolder = defaultFolder;
-            }
-            else {
-                outputFolder = path.join(path.dirname(sourceFile), 'schemas');
-            }
-            // Create folder if it doesn't exist
-            if (!fsSync.existsSync(outputFolder)) {
-                fsSync.mkdirSync(outputFolder, { recursive: true });
-            }
-            // Filter schemas to generate (allow user to select)
-            const schemaItems = schemas.map((s) => ({
-                label: (0, swaggerParser_1.generateSchemaFilename)(s.operationId, s.statusCode),
-                description: `${s.method} ${s.path} → ${s.statusCode}`,
-                picked: s.statusCode === '200' // Default select 200 responses
-            }));
-            const selectedSchemas = await vscode.window.showQuickPick(schemaItems, {
-                canPickMany: true,
-                placeHolder: 'Select schemas to generate',
-                title: `${schemas.length} response schemas available`
-            });
-            if (!selectedSchemas || selectedSchemas.length === 0) {
-                return;
-            }
-            const selectedFilenames = new Set(selectedSchemas.map(s => s.label));
-            // Write schema files
-            let createdCount = 0;
-            for (const schema of schemas) {
-                const filename = (0, swaggerParser_1.generateSchemaFilename)(schema.operationId, schema.statusCode);
-                if (!selectedFilenames.has(filename)) {
-                    continue;
-                }
-                const filePath = path.join(outputFolder, filename);
-                const content = JSON.stringify(schema.schema, null, 2);
-                fsSync.writeFileSync(filePath, content, 'utf-8');
-                createdCount++;
-            }
-            vscode.window.showInformationMessage(`Generated ${createdCount} schema files in ${path.basename(outputFolder)}/`);
-        }
-        catch (error) {
-            const errorMessage = error instanceof Error ? error.message : String(error);
-            vscode.window.showErrorMessage(`Failed to generate schemas: ${errorMessage}`);
-        }
-    });
-    // === Coverage Feature Setup ===
-    // 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 (nornapiFilePath) => {
-        try {
-            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);
-            vscode.window.showErrorMessage(`Failed to calculate coverage: ${errorMessage}`);
-        }
-    });
-    // Register command to refresh coverage
-    const refreshCoverageCommand = vscode.commands.registerCommand('norn.refreshCoverage', async (nornapiFilePath) => {
-        try {
-            (0, swaggerParser_1.invalidateSwaggerCache)();
-            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}%`);
-        }
-        catch (error) {
-            const errorMessage = error instanceof Error ? error.message : String(error);
-            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);
-        (0, codeLensProvider_1.updateCodeLensCoverage)(coverage.percentage, coverage.total, coverage.covered);
-        vscode.commands.executeCommand('norn.refreshCodeLenses');
-    });
-    // File watcher for .nornapi files - only recalculate when files are created/deleted
-    // (might add new swagger URLs that need fetching)
-    const nornapiFileWatcher = vscode.workspace.createFileSystemWatcher('**/*.nornapi');
-    const scheduleNornapiRefresh = debounce(async () => {
-        (0, coverageCalculator_1.clearCoverageCache)();
-        // Recalculate - this will fetch new swagger URLs if detected
-        try {
-            await (0, coverageCalculator_1.getCoverage)();
-        }
-        catch {
-            // Ignore errors in background refresh
-        }
-    }, 1000);
-    // Only watch for new/deleted .nornapi files (new swagger URLs)
-    nornapiFileWatcher.onDidCreate(() => scheduleNornapiRefresh());
-    nornapiFileWatcher.onDidDelete(() => scheduleNornapiRefresh());
-    // Watch for .norn and .nornapi file saves to update coverage
-    const scheduleCoverageUpdate = debounce(async () => {
-        (0, coverageCalculator_1.clearCoverageCache)();
-        try {
-            await (0, coverageCalculator_1.getCoverage)();
-        }
-        catch {
-            // Ignore errors in background refresh
-        }
-    }, 500);
-    const documentSaveWatcher = vscode.workspace.onDidSaveTextDocument((document) => {
-        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 () => {
-        try {
-            await (0, coverageCalculator_1.getCoverage)();
-        }
-        catch {
-            // 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
-    const codeLensProvider = vscode.languages.registerCodeLensProvider([
-        { language: 'norn', scheme: 'file' },
-        { language: 'nornapi', scheme: 'file' }
-    ], new codeLensProvider_1.HttpCodeLensProvider());
-    // Register the Completion provider for IntelliSense
-    const completionProvider = vscode.languages.registerCompletionItemProvider([
-        { language: 'norn', scheme: 'file' },
-        { language: 'nornapi', scheme: 'file' }
-    ], new completionProvider_1.HttpCompletionProvider(), 
-    // Trigger characters: 
-    // - '{' for variable references {{
-    // - '.' for property access ($N.body, user.body)
-    // - ' ' for after keywords (print, run, etc.)
-    // - '(' and ',' for parameter suggestions
-    // - '@' for sequence tags
-    // - ':' for header values (Content-Type: ...)
-    // - Letters for typing variable names inside () or after print
-    '{', '.', ' ', '(', ',', '@', ':', 'a', 'b', 'c', 'd', 'e', 'f', 'g', 'h', 'i', 'j', 'k', 'l', 'm', 'n', 'o', 'p', 'q', 'r', 's', 't', 'u', 'v', 'w', 'x', 'y', 'z', 'A', 'B', 'C', 'D', 'E', 'F', 'G', 'H', 'I', 'J', 'K', 'L', 'M', 'N', 'O', 'P', 'Q', 'R', 'S', 'T', 'U', 'V', 'W', 'X', 'Y', 'Z', '_');
-    // Register the Diagnostic provider for undefined variables
-    const diagnosticProvider = new diagnosticProvider_1.DiagnosticProvider();
-    // Register command to refresh diagnostics (called when environment changes)
-    const refreshDiagnosticsCommand = vscode.commands.registerCommand('norn.refreshDiagnostics', () => {
-        vscode.workspace.textDocuments.forEach((document) => {
-            if (document.languageId === 'norn' || document.languageId === 'nornenv' || document.languageId === 'nornapi') {
-                diagnosticProvider.updateDiagnostics(document);
-            }
-        });
-    });
-    // Register command to open Contract View for schema validation errors
-    const openContractViewCommand = vscode.commands.registerCommand('norn.openContractView', (data) => {
-        responsePanel_1.ResponsePanel.showContractView(context.extensionUri, data);
-    });
-    // Register command to open a schema file from CodeLens
-    const openSchemaFileCommand = vscode.commands.registerCommand('norn.openSchemaFile', async (schemaPath, sourceFile) => {
-        try {
-            // Get workspace root for @/ alias resolution
-            const workspaceRoot = vscode.workspace.workspaceFolders?.[0]?.uri.fsPath;
-            const sourceDir = path.dirname(sourceFile);
-            // Resolve the schema path (handles @/ alias for contracts folder)
-            const resolvedPath = (0, schemaGenerator_1.resolveSchemaPath)(schemaPath, sourceDir, workspaceRoot);
-            // Open the schema file
-            const uri = vscode.Uri.file(resolvedPath);
-            await vscode.commands.executeCommand('vscode.open', uri);
-        }
-        catch (error) {
-            vscode.window.showErrorMessage(`Could not open schema file: ${schemaPath}`);
-        }
-    });
-    // Register command to validate a schema assertion immediately
-    const validateSchemaAssertionNowCommand = vscode.commands.registerCommand('norn.validateSchemaAssertionNow', async (line, sourceFile) => {
-        try {
-            // Find the enclosing sequence and run it
-            const editor = vscode.window.activeTextEditor;
-            if (!editor || editor.document.uri.fsPath !== sourceFile) {
-                // Open the file if not already open
-                const doc = await vscode.workspace.openTextDocument(sourceFile);
-                await vscode.window.showTextDocument(doc);
-            }
-            // Run the sequence at this line
-            await vscode.commands.executeCommand('norn.runSequence', line);
-        }
-        catch (error) {
-            vscode.window.showErrorMessage(`Validation failed: ${error}`);
-        }
-    });
-    // Register command to view contract validation report
-    const viewContractReportCommand = vscode.commands.registerCommand('norn.viewContractReport', async (line, sourceFile, schemaPath) => {
-        try {
-            const editor = vscode.window.activeTextEditor;
-            if (!editor || editor.document.uri.fsPath !== sourceFile) {
-                const doc = await vscode.workspace.openTextDocument(sourceFile);
-                await vscode.window.showTextDocument(doc);
-            }
-            const activeEditor = vscode.window.activeTextEditor;
-            if (!activeEditor) {
-                vscode.window.showErrorMessage('No active editor');
-                return;
-            }
-            // Run the sequence and capture the result
-            const fullText = activeEditor.document.getText();
-            const workingDir = path.dirname(activeEditor.document.uri.fsPath);
-            const sequence = (0, sequenceRunner_1.getSequenceAtLine)(fullText, line);
-            if (!sequence) {
-                vscode.window.showErrorMessage('No sequence found at this line');
-                return;
-            }
-            // Get variables and run imports
-            const fileLevelVariables = (0, parser_1.extractFileLevelVariables)(fullText);
-            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');
-                return content;
-            });
-            const fullTextWithImports = importResult.importedContent
-                ? `${importResult.importedContent}\n\n${fullText}`
-                : fullText;
-            const apiDefinitions = (importResult.headerGroups && importResult.headerGroups.length > 0) ||
-                (importResult.endpoints && importResult.endpoints.length > 0)
-                ? { headerGroups: importResult.headerGroups || [], endpoints: importResult.endpoints || [] }
-                : undefined;
-            // Run the sequence
-            const result = await (0, sequenceRunner_1.runSequence)(sequence.content, allVariables, workingDir, fullTextWithImports, undefined, // no progress callback
-            undefined, // callStack
-            undefined, // defaultArgs
-            apiDefinitions, undefined, // tagFilterOptions
-            importResult.sequenceSources // track source files for script path resolution
-            );
-            // Find the matchesSchema assertion step that corresponds to this line
-            const assertionLineRelative = line - sequence.startLine - 1;
-            let matchingStep = result.steps.find(s => s.type === 'assertion' &&
-                s.assertion?.operator === 'matchesSchema' &&
-                s.lineNumber !== undefined &&
-                Math.abs(s.lineNumber - assertionLineRelative) <= 1);
-            // If not found by line, try to find any matchesSchema assertion with matching schema path
-            if (!matchingStep) {
-                matchingStep = result.steps.find(s => s.type === 'assertion' &&
-                    s.assertion?.operator === 'matchesSchema' &&
-                    (s.assertion?.schemaPath?.includes(schemaPath) || s.assertion?.rightValue?.includes(schemaPath)));
-            }
-            if (!matchingStep || !matchingStep.assertion) {
-                vscode.window.showErrorMessage('Could not find the schema assertion result. Try running the full sequence first.');
-                return;
-            }
-            // Get the response body used in the assertion
-            const responseBody = matchingStep.assertion.leftValue;
-            const schema = matchingStep.assertion.schema;
-            const errors = matchingStep.assertion.schemaErrors || [];
-            const resolvedSchemaPath = matchingStep.assertion.schemaPath || schemaPath;
-            // Show the Contract Report
-            responsePanel_1.ResponsePanel.showContractReport(context.extensionUri, {
-                schemaPath: resolvedSchemaPath,
-                errors,
-                responseBody,
-                schema,
-                assertionLine: line,
-                sourceFile
-            });
-            // Save validation results and refresh decorations
-            saveSchemaValidationResults(result, activeEditor.document.uri.fsPath, sequence.startLine + 1);
-        }
-        catch (error) {
-            vscode.window.showErrorMessage(`Failed to generate contract report: ${error}`);
-        }
-    });
-    // Register the Contract Decoration provider for schema assertion status indicators
-    const contractDecorationProvider = new contractDecorationProvider_1.ContractDecorationProvider();
-    contractDecorationProviderInstance = contractDecorationProvider;
-    // Register hover provider for schema assertion lines
-    const contractHoverProvider = vscode.languages.registerHoverProvider({ language: 'norn' }, (0, contractDecorationProvider_1.createContractHoverProvider)());
-    // Update diagnostics when document changes
-    const onDidChangeDocument = vscode.workspace.onDidChangeTextDocument((event) => {
-        if (event.document.languageId === 'norn' || event.document.languageId === 'nornenv' || event.document.languageId === 'nornapi') {
-            diagnosticProvider.updateDiagnostics(event.document);
-        }
-    });
-    // Update diagnostics when document opens
-    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);
-    });
-    // Update diagnostics for already open documents
-    vscode.workspace.textDocuments.forEach((document) => {
-        if (document.languageId === 'norn' || document.languageId === 'nornenv' || document.languageId === 'nornapi') {
-            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, onDidChangeActiveEditor, onDidCloseDocument, nornapiFileWatcher, documentSaveWatcher, { dispose: environmentProvider_1.disposeStatusBar });
-}
-function formatSequenceCaseLabel(caseParams, index) {
-    const entries = Object.entries(caseParams);
-    if (entries.length === 0) {
-        return `Case ${index + 1}`;
-    }
-    const formatted = entries.map(([key, value]) => {
-        if (typeof value === 'string') {
-            return `${key}="${value}"`;
-        }
-        return `${key}=${value}`;
-    });
-    return `[${formatted.join(', ')}]`;
-}
-function normalizeTheoryCase(caseValue, sequenceParamNames) {
-    if (caseValue && typeof caseValue === 'object' && !Array.isArray(caseValue)) {
-        return caseValue;
-    }
-    if (sequenceParamNames.length === 1) {
-        return { [sequenceParamNames[0]]: caseValue };
-    }
-    return null;
-}
-async function loadTheoryCasesFromSource(sourcePath, workingDir, sequence) {
-    const resolvedPath = path.resolve(workingDir, sourcePath);
-    const content = await fs.readFile(resolvedPath, 'utf-8');
-    const parsed = JSON.parse(content);
-    if (!Array.isArray(parsed)) {
-        throw new Error(`Theory file "${sourcePath}" must contain a JSON array of test cases`);
-    }
-    const paramNames = sequence.parameters.map(p => p.name);
-    const cases = [];
-    for (let i = 0; i < parsed.length; i++) {
-        const normalized = normalizeTheoryCase(parsed[i], paramNames);
-        if (!normalized) {
-            throw new Error(`Theory file "${sourcePath}" has invalid case at index ${i}. ` +
-                `Use objects for multi-parameter sequences.`);
-        }
-        cases.push(normalized);
-    }
-    return cases;
-}
-async function resolveSequenceRunCases(sequence, workingDir, defaultArgs) {
-    const inlineCases = sequence.theoryData?.cases || [];
-    let finalCases = [];
-    if (inlineCases.length > 0) {
-        finalCases = inlineCases;
-    }
-    else if (sequence.theoryData?.source) {
-        finalCases = await loadTheoryCasesFromSource(sequence.theoryData.source, workingDir, sequence);
-    }
-    if (finalCases.length === 0) {
-        return [{ args: { ...defaultArgs } }];
-    }
-    return finalCases.map((caseParams, index) => {
-        const args = { ...defaultArgs };
-        for (const [key, value] of Object.entries(caseParams)) {
-            if (value !== undefined) {
-                args[key] = String(value);
-            }
-        }
-        return {
-            label: formatSequenceCaseLabel(caseParams, index),
-            args
-        };
-    });
-}
-async function processSequence(extensionUri, lineFromCodeLens) {
-    const editor = vscode.window.activeTextEditor;
-    if (!editor) {
-        vscode.window.showErrorMessage("No active editor");
-        return;
-    }
-    const fullText = editor.document.getText();
-    const targetLine = lineFromCodeLens ?? editor.selection.active.line;
-    const sequence = (0, sequenceRunner_1.getSequenceAtLine)(fullText, targetLine);
-    if (!sequence) {
-        vscode.window.showErrorMessage("No sequence found at cursor position");
-        return;
-    }
-    // Merge environment variables with file-level variables (outside sequences)
-    // Variables inside sequences are local to that sequence
-    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
-    const defaultArgs = {};
-    if (sequence.parameters) {
-        for (const param of sequence.parameters) {
-            if (param.defaultValue !== undefined) {
-                defaultArgs[param.name] = param.defaultValue;
-            }
-        }
-    }
-    // Get working directory from the file's location
-    const workingDir = path.dirname(editor.document.uri.fsPath);
-    // Resolve imports to get the full document text with imported requests/sequences
-    const importResult = await (0, parser_1.resolveImports)(fullText, workingDir, async (filePath) => {
-        const content = await fs.readFile(filePath, 'utf-8');
-        return content;
-    });
-    // Show import errors - duplicate errors block execution, others are warnings
-    const duplicateErrors = importResult.errors.filter(err => err.error.includes('Duplicate header group') ||
-        err.error.includes('Duplicate endpoint') ||
-        err.error.includes('Duplicate named request') ||
-        err.error.includes('Duplicate sequence'));
-    const otherErrors = importResult.errors.filter(err => !err.error.includes('Duplicate header group') &&
-        !err.error.includes('Duplicate endpoint') &&
-        !err.error.includes('Duplicate named request') &&
-        !err.error.includes('Duplicate sequence'));
-    // Show non-duplicate errors as warnings
-    for (const err of otherErrors) {
-        vscode.window.showWarningMessage(`Import error: ${err.path} - ${err.error}`);
-    }
-    // Duplicate errors block execution
-    if (duplicateErrors.length > 0) {
-        vscode.window.showErrorMessage(`Cannot run sequence - duplicate definitions found:\n${duplicateErrors[0].error}`);
-        return;
-    }
-    // Combine original text with imported content
-    const fullTextWithImports = importResult.importedContent
-        ? `${importResult.importedContent}\n\n${fullText}`
-        : fullText;
-    // Build API definitions from imports (header groups and endpoints from .nornapi files)
-    const apiDefinitions = (importResult.headerGroups && importResult.headerGroups.length > 0) ||
-        (importResult.endpoints && importResult.endpoints.length > 0)
-        ? { headerGroups: importResult.headerGroups || [], endpoints: importResult.endpoints || [] }
-        : undefined;
-    let executedRuns = false;
-    try {
-        const runCases = await resolveSequenceRunCases(sequence, workingDir, defaultArgs);
-        if (runCases.length <= 1) {
-            // Single run: keep streaming behavior.
-            const totalSteps = (0, sequenceRunner_1.countSequenceSteps)(sequence.content);
-            responsePanel_1.ResponsePanel.startSequenceRun(extensionUri, sequence.name, totalSteps, editor.document.uri.fsPath);
-            try {
-                executedRuns = true;
-                const runArgs = runCases[0]?.args ?? defaultArgs;
-                const result = await (0, sequenceRunner_1.runSequence)(sequence.content, allVariables, workingDir, fullTextWithImports, (progressInfo) => {
-                    // Handle sequence start/end markers for grouping
-                    if (progressInfo.stepType === 'sequenceStart' || progressInfo.stepType === 'sequenceEnd') {
-                        responsePanel_1.ResponsePanel.addSequenceStep(undefined, progressInfo);
-                    }
-                    // Stream each step result to the panel as it completes
-                    else if (progressInfo.stepResult) {
-                        responsePanel_1.ResponsePanel.addSequenceStep(progressInfo.stepResult, progressInfo);
-                    }
-                }, undefined, // callStack
-                runArgs, apiDefinitions, // header groups and endpoints from .nornapi imports
-                undefined, // tagFilterOptions
-                importResult.sequenceSources // track source files for script path resolution
-                );
-                result.name = sequence.name;
-                responsePanel_1.ResponsePanel.finalizeSequence(result);
-                // Save validation results for schema assertions and refresh decorations
-                // Add sequence.startLine + 1 to convert relative line numbers to absolute file line numbers
-                // (+1 because the sequence content starts after the "sequence ..." declaration line)
-                saveSchemaValidationResults(result, editor.document.uri.fsPath, sequence.startLine + 1);
-            }
-            catch (error) {
-                const errorMessage = error instanceof Error ? error.message : String(error);
-                vscode.window.showErrorMessage(`Sequence failed: ${errorMessage}`);
-                // Finalize with error state
-                responsePanel_1.ResponsePanel.finalizeSequence({
-                    name: sequence.name,
-                    success: false,
-                    responses: [],
-                    scriptResults: [],
-                    assertionResults: [],
-                    steps: [],
-                    errors: [errorMessage],
-                    duration: 0
-                });
-            }
-        }
-        else {
-            // Parameterized runs: execute all cases and show combined report in one panel.
-            const caseResults = [];
-            await vscode.window.withProgress({
-                location: vscode.ProgressLocation.Notification,
-                title: `Running ${sequence.name} (${runCases.length} cases)`,
-                cancellable: false
-            }, async (progress) => {
-                for (let i = 0; i < runCases.length; i++) {
-                    const runCase = runCases[i];
-                    const runLabel = runCase.label || `Case ${i + 1}`;
-                    progress.report({
-                        message: runLabel,
-                        increment: 100 / runCases.length
-                    });
-                    try {
-                        executedRuns = true;
-                        const result = await (0, sequenceRunner_1.runSequence)(sequence.content, allVariables, workingDir, fullTextWithImports, undefined, // no per-step streaming in multi-run mode
-                        undefined, // callStack
-                        runCase.args, apiDefinitions, undefined, importResult.sequenceSources);
-                        result.name = sequence.name;
-                        saveSchemaValidationResults(result, editor.document.uri.fsPath, sequence.startLine + 1);
-                        caseResults.push({ label: runLabel, result });
-                    }
-                    catch (error) {
-                        const errorMessage = error instanceof Error ? error.message : String(error);
-                        caseResults.push({
-                            label: runLabel,
-                            result: {
-                                name: sequence.name,
-                                success: false,
-                                responses: [],
-                                scriptResults: [],
-                                assertionResults: [],
-                                steps: [],
-                                errors: [errorMessage],
-                                duration: 0
-                            }
-                        });
-                    }
-                }
-            });
-            responsePanel_1.ResponsePanel.showMultiSequenceResult(extensionUri, sequence.name, caseResults);
-        }
-        if (executedRuns) {
-            // Recalculate coverage after sequence execution (uses cached swagger specs)
-            (0, coverageCalculator_1.recalculateCoverageAfterExecution)().catch(() => {
-                // Silently ignore coverage calculation errors
-            });
-        }
-    }
-    catch (error) {
-        const errorMessage = error instanceof Error ? error.message : String(error);
-        vscode.window.showErrorMessage(`Sequence failed: ${errorMessage}`);
-    }
-}
-/**
- * Save schema validation results to cache and refresh decorations
- */
-function saveSchemaValidationResults(result, sourceFile, lineOffset = 0) {
-    try {
-        // Find all matchesSchema assertion steps
-        for (const step of result.steps) {
-            if (step.type === 'assertion' && step.assertion?.operator === 'matchesSchema') {
-                const assertion = step.assertion;
-                const schemaPath = assertion.schemaPath || assertion.rightValue || '';
-                const status = assertion.passed ? 'pass' : 'fail';
-                const errorCount = assertion.schemaErrors?.length || 0;
-                const errorSummary = assertion.schemaErrors?.[0]?.message || assertion.error?.substring(0, 100);
-                // Only cache if we have a line number
-                if (step.lineNumber !== undefined) {
-                    // Convert relative line number to absolute file line number using lineOffset
-                    const absoluteLine = step.lineNumber + lineOffset;
-                    (0, validationCache_1.saveValidationResult)({
-                        schemaPath,
-                        sourceFile,
-                        assertionLine: absoluteLine,
-                        status,
-                        lastRunTime: new Date().toISOString(),
-                        errorCount: status === 'fail' ? errorCount : undefined,
-                        errorSummary: status === 'fail' ? errorSummary : undefined
-                    });
-                }
-            }
-        }
-        // Refresh decorations
-        contractDecorationProviderInstance?.refreshAllDecorations();
-    }
-    catch (e) {
-        // Silently ignore cache errors
-        console.error('Failed to save validation results:', e);
-    }
-}
-async function processEditorsInput(extensionUri, lineFromCodeLens) {
-    const editor = vscode.window.activeTextEditor;
-    if (!editor) {
-        vscode.window.showErrorMessage("No active editor");
-        return;
-    }
-    const fullText = editor.document.getText();
-    const selection = editor.selection;
-    let requestText;
-    if (!selection.isEmpty) {
-        // User selected specific text
-        requestText = editor.document.getText(selection);
-    }
-    else {
-        // Use line from CodeLens if provided, otherwise use cursor position
-        const targetLine = lineFromCodeLens ?? selection.active.line;
-        requestText = (0, parser_1.getRequestBlockAtLine)(fullText, targetLine);
-    }
-    // Get working directory from the file's location
-    const workingDir = path.dirname(editor.document.uri.fsPath);
-    try {
-        // Extract variables: environment + file (file takes precedence)
-        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)
-        const importResult = await (0, parser_1.resolveImports)(fullText, workingDir, async (filePath) => {
-            const content = await fs.readFile(filePath, 'utf-8');
-            return content;
-        });
-        // Check for duplicate definition errors which should block execution
-        const duplicateErrors = importResult.errors.filter(err => err.error.includes('Duplicate header group') ||
-            err.error.includes('Duplicate endpoint') ||
-            err.error.includes('Duplicate named request') ||
-            err.error.includes('Duplicate sequence'));
-        if (duplicateErrors.length > 0) {
-            vscode.window.showErrorMessage(`Cannot run request - duplicate definitions found:\n${duplicateErrors[0].error}`);
-            return;
-        }
-        // Build API definitions from imports
-        const apiDefinitions = (importResult.headerGroups && importResult.headerGroups.length > 0) ||
-            (importResult.endpoints && importResult.endpoints.length > 0)
-            ? { headerGroups: importResult.headerGroups || [], endpoints: importResult.endpoints || [] }
-            : undefined;
-        let parsed;
-        let requestDescription;
-        // Check if this is an API request (uses endpoint syntax like GET GetPetById(1))
-        if (apiDefinitions &&
-            apiDefinitions.endpoints.length > 0 &&
-            (0, nornapiParser_1.isApiRequestLine)(requestText, apiDefinitions.endpoints)) {
-            const apiRequest = (0, nornapiParser_1.parseApiRequest)(requestText, apiDefinitions.endpoints, apiDefinitions.headerGroups);
-            if (apiRequest) {
-                const endpoint = (0, nornapiParser_1.getEndpoint)({ headerGroups: apiDefinitions.headerGroups, endpoints: apiDefinitions.endpoints }, apiRequest.endpointName);
-                if (endpoint) {
-                    // Substitute {{variable}} references in the endpoint path
-                    let resolvedPath = endpoint.path;
-                    for (const [key, value] of Object.entries(variables)) {
-                        resolvedPath = resolvedPath.replace(new RegExp(`\\{\\{${key}\\}\\}`, 'g'), String(value));
-                    }
-                    // Substitute {param} placeholders with the values passed to the endpoint
-                    for (const [paramName, paramValue] of Object.entries(apiRequest.params)) {
-                        // Resolve variable references in param values
-                        let resolvedValue = paramValue;
-                        if (variables[paramValue] !== undefined) {
-                            resolvedValue = String(variables[paramValue]);
-                        }
-                        else if (paramValue.startsWith('{{') && paramValue.endsWith('}}')) {
-                            const varName = paramValue.slice(2, -2);
-                            if (variables[varName] !== undefined) {
-                                resolvedValue = String(variables[varName]);
-                            }
-                        }
-                        resolvedPath = resolvedPath.replace(`{${paramName}}`, resolvedValue);
-                    }
-                    // Collect headers from header groups
-                    const combinedHeaders = {};
-                    for (const groupName of apiRequest.headerGroupNames) {
-                        const group = apiDefinitions.headerGroups.find(hg => hg.name === groupName);
-                        if (group) {
-                            const resolvedHeaders = (0, nornapiParser_1.resolveHeaderValues)(group, variables);
-                            Object.assign(combinedHeaders, resolvedHeaders);
-                        }
-                    }
-                    // Add inline headers (these take precedence over header groups)
-                    for (const [headerName, headerValue] of Object.entries(apiRequest.inlineHeaders)) {
-                        // Resolve variable references in header values
-                        let resolved = headerValue;
-                        resolved = resolved.replace(/\{\{([a-zA-Z_][a-zA-Z0-9_]*)\}\}/g, (_, varName) => {
-                            return variables[varName] !== undefined ? String(variables[varName]) : `{{${varName}}}`;
-                        });
-                        combinedHeaders[headerName] = resolved;
-                    }
-                    // Parse the request text to extract body (if any)
-                    const parsedForBody = (0, parser_1.parserHttpRequest)(requestText, variables);
-                    parsed = {
-                        method: apiRequest.method,
-                        url: resolvedPath,
-                        headers: combinedHeaders,
-                        body: parsedForBody.body
-                    };
-                    requestDescription = `${apiRequest.endpointName}(${Object.values(apiRequest.params).join(', ')}) → ${parsed.method} ${parsed.url}`;
-                }
-                else {
-                    throw new Error(`Unknown endpoint: ${apiRequest.endpointName}`);
-                }
-            }
-            else {
-                // Fallback to regular parsing
-                parsed = (0, parser_1.parserHttpRequest)(requestText, variables);
-                requestDescription = `${parsed.method} ${parsed.url}`;
-            }
-        }
-        else {
-            // Regular HTTP request
-            parsed = (0, parser_1.parserHttpRequest)(requestText, variables);
-            requestDescription = `${parsed.method} ${parsed.url}`;
-            // Check for header group names in the request text
-            // This allows: GET https://example.com Json Auth
-            // Or:          GET https://example.com
-            //              Json
-            //              Auth
-            if (apiDefinitions && apiDefinitions.headerGroups.length > 0) {
-                const requestLines = requestText.split('\n');
-                const headerGroupNames = apiDefinitions.headerGroups.map(hg => hg.name);
-                const foundGroups = [];
-                for (const line of requestLines) {
-                    const trimmed = line.trim();
-                    // Skip empty lines, comments, variable lines
-                    if (!trimmed || trimmed.startsWith('#') || trimmed.startsWith('var ')) {
-                        continue;
-                    }
-                    // Check if this is the HTTP method line - look for header groups at the end
-                    const methodMatch = trimmed.match(/^(GET|POST|PUT|DELETE|PATCH|HEAD|OPTIONS)\s+(.+)$/i);
-                    if (methodMatch) {
-                        const afterMethod = methodMatch[2];
-                        const tokens = afterMethod.split(/\s+/);
-                        // Scan from the end to find header groups
-                        for (let i = tokens.length - 1; i >= 0; i--) {
-                            if (headerGroupNames.includes(tokens[i])) {
-                                foundGroups.push(tokens[i]);
-                            }
-                            else {
-                                break;
-                            }
-                        }
-                        continue;
-                    }
-                    // Skip lines that look like headers (Name: Value)
-                    if (/^[A-Za-z0-9\-_]+\s*:\s*.+$/.test(trimmed)) {
-                        continue;
-                    }
-                    // Check if this line contains header group names (can be multiple space-separated)
-                    const potentialGroups = trimmed.split(/\s+/);
-                    for (const groupName of potentialGroups) {
-                        if (headerGroupNames.includes(groupName)) {
-                            foundGroups.push(groupName);
-                        }
-                    }
-                }
-                // Collect headers from all found groups and strip from URL
-                for (const groupName of foundGroups) {
-                    const group = apiDefinitions.headerGroups.find(hg => hg.name === groupName);
-                    if (group) {
-                        const resolvedHeaders = (0, nornapiParser_1.resolveHeaderValues)(group, variables);
-                        parsed.headers = { ...resolvedHeaders, ...parsed.headers };
-                    }
-                    // Strip from URL
-                    const endPattern = new RegExp(`\\s+${groupName}$`);
-                    parsed.url = parsed.url.replace(endPattern, '');
-                }
-                parsed.url = parsed.url.trim();
-                requestDescription = `${parsed.method} ${parsed.url}`;
-            }
-        }
-        // Show loading indicator
-        await vscode.window.withProgress({
-            location: vscode.ProgressLocation.Notification,
-            title: `Sending ${parsed.method} request...`,
-            cancellable: false
-        }, async () => {
-            try {
-                const response = await (0, httpClient_1.sendRequest)(parsed);
-                responsePanel_1.ResponsePanel.show(extensionUri, parsed.method, parsed.url, response);
-            }
-            catch (error) {
-                responsePanel_1.ResponsePanel.showError(extensionUri, parsed.method, parsed.url, error.message);
-            }
-        });
-    }
-    catch (error) {
-        vscode.window.showErrorMessage(error.message);
-    }
-}
-/**
- * Simple debounce helper
- */
-function debounce(fn, delay) {
-    let timeoutId;
-    return ((...args) => {
-        if (timeoutId) {
-            clearTimeout(timeoutId);
-        }
-        timeoutId = setTimeout(() => {
-            fn(...args);
-            timeoutId = undefined;
-        }, 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)();
-    (0, coverageCalculator_1.clearCoverageCache)();
-}
-//# sourceMappingURL=extension.js.map