norn-cli 1.3.16 → 1.3.18

package/out/extension.js

@@ -0,0 +1,1025 @@
+"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");
+// 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);
+    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;
+                }
+                // 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 () => {
+        try {
+            const coverage = await (0, coverageCalculator_1.getCoverage)();
+            coveragePanel_1.CoveragePanel.show(coverage);
+        }
+        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 () => {
+        try {
+            (0, swaggerParser_1.invalidateSwaggerCache)();
+            const coverage = 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}`);
+        }
+    });
+    // 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();
+        }
+    });
+    // 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);
+    // 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)();
+            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);
+        }
+    });
+    // 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, 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)();
+    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)();
+        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 deactivate() {
+    // Clear caches on deactivation
+    (0, swaggerParser_1.clearSwaggerCache)();
+    (0, coverageCalculator_1.clearCoverageCache)();
+}
+//# sourceMappingURL=extension.js.map