norn-cli 2.2.2 → 2.4.0

package/out/cli/reporters/index.js

@@ -0,0 +1,22 @@
+"use strict";
+/**
+ * CLI reporters index - re-exports all reporter functions
+ */
+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 __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./junit"), exports);
+__exportStar(require("./html"), exports);
+//# sourceMappingURL=index.js.map

package/out/cli/reporters/junit.js

@@ -0,0 +1,226 @@
+"use strict";
+/**
+ * JUnit XML reporter for CI/CD integration
+ *
+ * Generates JUnit XML format that's compatible with:
+ * - Azure DevOps (ADO)
+ * - Jenkins
+ * - GitHub Actions
+ * - GitLab CI
+ * - CircleCI
+ * - Most CI/CD platforms
+ */
+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.generateJUnitReport = generateJUnitReport;
+exports.generateJUnitReportFromResponse = generateJUnitReportFromResponse;
+const fs = __importStar(require("fs"));
+const redaction_1 = require("../redaction");
+/**
+ * Escape XML special characters
+ */
+function escapeXml(text) {
+    return text
+        .replace(/&/g, '&amp;')
+        .replace(/</g, '&lt;')
+        .replace(/>/g, '&gt;')
+        .replace(/"/g, '&quot;')
+        .replace(/'/g, '&apos;');
+}
+/**
+ * Format duration as seconds with 3 decimal places
+ */
+function formatDurationSeconds(ms) {
+    return (ms / 1000).toFixed(3);
+}
+/**
+ * Generate JUnit XML report from sequence results
+ */
+function generateJUnitReport(results, options) {
+    const { outputPath, redaction, suiteName = 'Norn Tests' } = options;
+    const totalTests = results.reduce((sum, r) => sum + Math.max(1, r.assertionResults?.length || 0), 0);
+    const totalFailures = results.reduce((sum, r) => sum + (r.assertionResults?.filter(a => !a.passed).length || (r.success ? 0 : 1)), 0);
+    const totalDuration = results.reduce((sum, r) => sum + r.duration, 0);
+    const totalErrors = results.filter(r => r.errors.length > 0 && r.success === false).length;
+    let xml = '<?xml version="1.0" encoding="UTF-8"?>\n';
+    xml += `<testsuites name="${escapeXml(suiteName)}" tests="${totalTests}" failures="${totalFailures}" errors="${totalErrors}" time="${formatDurationSeconds(totalDuration)}">\n`;
+    for (const result of results) {
+        xml += generateTestSuite(result, redaction);
+    }
+    xml += '</testsuites>\n';
+    fs.writeFileSync(outputPath, xml, 'utf-8');
+}
+/**
+ * Generate a testsuite element for a sequence
+ */
+function generateTestSuite(result, redaction) {
+    const assertions = result.assertionResults || [];
+    const testCount = Math.max(1, assertions.length);
+    const failures = assertions.filter(a => !a.passed).length + (result.success ? 0 : (assertions.length === 0 ? 1 : 0));
+    let xml = `  <testsuite name="${escapeXml(result.name)}" tests="${testCount}" failures="${failures}" errors="0" time="${formatDurationSeconds(result.duration)}">\n`;
+    if (assertions.length > 0) {
+        // Create a testcase for each assertion
+        for (const assertion of assertions) {
+            xml += generateTestCase(result.name, assertion, redaction);
+        }
+    }
+    else {
+        // No assertions - create a single testcase for the sequence
+        xml += generateSequenceTestCase(result, redaction);
+    }
+    // Add system-out with request/response details
+    xml += generateSystemOut(result, redaction);
+    // Add system-err with errors
+    if (result.errors.length > 0) {
+        xml += `    <system-err><![CDATA[${result.errors.map(e => (0, redaction_1.redactString)(e, redaction)).join('\n')}]]></system-err>\n`;
+    }
+    xml += '  </testsuite>\n';
+    return xml;
+}
+/**
+ * Generate a testcase element for an assertion
+ */
+function generateTestCase(sequenceName, assertion, redaction) {
+    const testName = assertion.message || assertion.expression;
+    const className = sequenceName;
+    let xml = `    <testcase name="${escapeXml(testName)}" classname="${escapeXml(className)}">\n`;
+    if (!assertion.passed) {
+        const message = assertion.error || `Expected ${assertion.rightExpression || assertion.rightValue}, got ${JSON.stringify(assertion.leftValue)}`;
+        xml += `      <failure message="${escapeXml((0, redaction_1.redactString)(message, redaction))}" type="AssertionError">\n`;
+        xml += `<![CDATA[Expression: ${assertion.expression}\n`;
+        xml += `Expected: ${JSON.stringify(assertion.rightValue)}\n`;
+        xml += `Actual: ${JSON.stringify(assertion.leftValue)}]]>\n`;
+        xml += '      </failure>\n';
+    }
+    xml += '    </testcase>\n';
+    return xml;
+}
+/**
+ * Generate a testcase element for a sequence without assertions
+ */
+function generateSequenceTestCase(result, redaction) {
+    let xml = `    <testcase name="${escapeXml(result.name)}" classname="${escapeXml(result.name)}" time="${formatDurationSeconds(result.duration)}">\n`;
+    if (!result.success) {
+        const errorMessages = result.errors.length > 0
+            ? result.errors.map(e => (0, redaction_1.redactString)(e, redaction)).join('; ')
+            : 'Sequence failed';
+        xml += `      <failure message="${escapeXml(errorMessages)}" type="SequenceError">\n`;
+        xml += `<![CDATA[${errorMessages}]]>\n`;
+        xml += '      </failure>\n';
+    }
+    xml += '    </testcase>\n';
+    return xml;
+}
+/**
+ * Generate system-out with request/response details
+ */
+function generateSystemOut(result, redaction) {
+    const lines = [];
+    for (const step of result.steps) {
+        if (step.type === 'request' && step.response) {
+            const url = step.requestUrl ? (0, redaction_1.redactUrl)(step.requestUrl, redaction) : 'unknown';
+            lines.push(`[${step.requestMethod || 'REQUEST'}] ${url}`);
+            lines.push(`  Status: ${step.response.status} ${step.response.statusText}`);
+            lines.push(`  Duration: ${step.response.duration}ms`);
+            if (step.response.body) {
+                const bodyStr = typeof step.response.body === 'object'
+                    ? JSON.stringify((0, redaction_1.redactBody)(step.response.body, redaction), null, 2)
+                    : (0, redaction_1.redactString)(String(step.response.body), redaction);
+                // Truncate long bodies
+                if (bodyStr.length > 1000) {
+                    lines.push(`  Body: ${bodyStr.substring(0, 1000)}... (truncated)`);
+                }
+                else {
+                    lines.push(`  Body: ${bodyStr}`);
+                }
+            }
+            lines.push('');
+        }
+        else if (step.type === 'print' && step.print) {
+            lines.push(`[PRINT] ${step.print.title}`);
+            if (step.print.body) {
+                lines.push(`  ${step.print.body}`);
+            }
+        }
+        else if (step.type === 'mcp' && step.mcp) {
+            if (step.mcp.operation === 'list') {
+                lines.push(`[MCP LIST] ${step.mcp.serverAlias}`);
+                lines.push(`  Tools: ${(step.mcp.tools || []).map(tool => tool.name).join(', ')}`);
+            }
+            else {
+                lines.push(`[MCP CALL] ${step.mcp.serverAlias}.${step.mcp.toolName || ''}`);
+                if (step.mcp.result?.text) {
+                    lines.push(`  Text: ${(0, redaction_1.redactString)(step.mcp.result.text, redaction)}`);
+                }
+                if (step.mcp.result?.structuredContent) {
+                    lines.push(`  Structured: ${JSON.stringify(step.mcp.result.structuredContent)}`);
+                }
+            }
+        }
+    }
+    if (lines.length === 0) {
+        return '';
+    }
+    return `    <system-out><![CDATA[${lines.join('\n')}]]></system-out>\n`;
+}
+/**
+ * Generate JUnit report from a single HTTP response (for non-sequence runs)
+ */
+function generateJUnitReportFromResponse(response, testName, options) {
+    const { outputPath, redaction, suiteName = 'Norn Tests' } = options;
+    const isSuccess = response.status >= 200 && response.status < 300;
+    const failures = isSuccess ? 0 : 1;
+    let xml = '<?xml version="1.0" encoding="UTF-8"?>\n';
+    xml += `<testsuites name="${escapeXml(suiteName)}" tests="1" failures="${failures}" errors="0" time="${formatDurationSeconds(response.duration)}">\n`;
+    xml += `  <testsuite name="${escapeXml(testName)}" tests="1" failures="${failures}" errors="0" time="${formatDurationSeconds(response.duration)}">\n`;
+    xml += `    <testcase name="${escapeXml(testName)}" classname="${escapeXml(testName)}" time="${formatDurationSeconds(response.duration)}">\n`;
+    if (!isSuccess) {
+        xml += `      <failure message="HTTP ${response.status} ${response.statusText}" type="HttpError">\n`;
+        xml += `<![CDATA[Status: ${response.status} ${response.statusText}`;
+        if (response.body) {
+            const bodyStr = typeof response.body === 'object'
+                ? JSON.stringify((0, redaction_1.redactBody)(response.body, redaction), null, 2)
+                : (0, redaction_1.redactString)(String(response.body), redaction);
+            xml += `\nResponse: ${bodyStr}`;
+        }
+        xml += ']]>\n';
+        xml += '      </failure>\n';
+    }
+    xml += '    </testcase>\n';
+    xml += '  </testsuite>\n';
+    xml += '</testsuites>\n';
+    fs.writeFileSync(outputPath, xml, 'utf-8');
+}
+//# sourceMappingURL=junit.js.map

package/out/codeLensProvider.js

@@ -0,0 +1,351 @@
+"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.HttpCodeLensProvider = void 0;
+exports.updateCodeLensCoverage = updateCodeLensCoverage;
+const vscode = __importStar(require("vscode"));
+const environmentProvider_1 = require("./environmentProvider");
+const envFileSecrets_1 = require("./secrets/envFileSecrets");
+const crypto_1 = require("./secrets/crypto");
+const environmentParser_1 = require("./environmentParser");
+const nornenvRegionRefactor_1 = require("./nornenvRegionRefactor");
+// Cached coverage percentage for CodeLens display
+/**
+ * Update the cached coverage for CodeLens display
+ */
+function updateCodeLensCoverage(percentage, total, covered) {
+    void percentage;
+    void total;
+    void covered;
+}
+/**
+ * Checks if a sequence declaration has only optional parameters (all have defaults).
+ * Returns true if no parameters or all parameters have defaults.
+ */
+function canRunSequenceWithoutArgs(line) {
+    // Check if there are parameters
+    const parenMatch = line.match(/\(([^)]*)\)/);
+    if (!parenMatch) {
+        // No parameters - can run
+        return true;
+    }
+    const paramsStr = parenMatch[1].trim();
+    if (!paramsStr) {
+        // Empty parens - can run
+        return true;
+    }
+    // Split by comma (simple split, not handling quoted strings with commas)
+    const params = paramsStr.split(',');
+    // Check each parameter has a default (contains =)
+    for (const param of params) {
+        const trimmed = param.trim();
+        if (!trimmed) {
+            continue;
+        }
+        // Must contain = for a default value
+        if (!trimmed.includes('=')) {
+            return false;
+        }
+    }
+    return true;
+}
+/**
+ * Checks for @data(...) or @theory(...) annotations directly above a sequence declaration.
+ * This allows CodeLens execution for parameterized sequences with required parameters.
+ */
+function hasTheoryAnnotationsAbove(document, sequenceLine) {
+    const dataOrTheoryPattern = /^@(data|theory)\s*\(/;
+    const decoratorPattern = /^@/;
+    for (let i = sequenceLine - 1; i >= 0; i--) {
+        const line = document.lineAt(i).text.trim();
+        // Allow blank lines between decorators and sequence declaration
+        if (!line) {
+            continue;
+        }
+        // Stop as soon as the decorator block ends
+        if (!decoratorPattern.test(line)) {
+            break;
+        }
+        if (dataOrTheoryPattern.test(line)) {
+            return true;
+        }
+    }
+    return false;
+}
+class HttpCodeLensProvider {
+    _onDidChangeCodeLenses = new vscode.EventEmitter();
+    onDidChangeCodeLenses = this._onDidChangeCodeLenses.event;
+    constructor() {
+        // Refresh code lenses when environment changes
+        vscode.commands.registerCommand('norn.refreshCodeLenses', () => {
+            this._onDidChangeCodeLenses.fire();
+        });
+    }
+    /**
+     * Gets the environment display text for CodeLens
+     * Returns 'add' if no env file exists, environment name if it does
+     */
+    getEnvDisplay(documentPath) {
+        const envFile = (0, environmentProvider_1.findEnvFileFromPath)(documentPath);
+        if (!envFile) {
+            return { text: '+ Add env file', hasEnvFile: false };
+        }
+        const activeEnv = (0, environmentProvider_1.getActiveEnvironment)(documentPath);
+        const availableEnvs = (0, environmentProvider_1.getAvailableEnvironments)(envFile);
+        if (availableEnvs.length === 0) {
+            return { text: 'env: (empty)', hasEnvFile: true };
+        }
+        return { text: activeEnv ? `env: ${activeEnv}` : 'env: none', hasEnvFile: true };
+    }
+    provideCodeLenses(document) {
+        const codeLenses = [];
+        const methodRegex = /^(GET|POST|PUT|DELETE|PATCH|HEAD|OPTIONS)\s+/;
+        // Match sequence (with optional test keyword) and optional parameters
+        const sequenceRegex = /^(?:test\s+)?sequence\s+([a-zA-Z_][a-zA-Z0-9_-]*)(?:\s*\([^)]*\))?$/;
+        // Match swagger statement with optional quotes around URL (only in .nornapi files)
+        const swaggerRegex = /^swagger\s+["']?(https?:\/\/[^\s"']+)["']?\s*$/;
+        // Match matchesSchema assertions: assert $1.body matchesSchema "./schema.json"
+        // Note: .+? is non-greedy to not consume matchesSchema
+        const matchesSchemaRegex = /^\s*assert\s+.+?\s+matchesSchema\s+["']?([^"']+)["']?/i;
+        const envInfo = this.getEnvDisplay(document.uri.fsPath);
+        const isNornApiFile = document.languageId === 'nornapi';
+        const isNornFile = document.languageId === 'norn';
+        const isNornenvFile = (0, envFileSecrets_1.isNornenvDocumentLike)(document.languageId, document.uri.fsPath);
+        const secretLinesByNumber = isNornenvFile
+            ? new Map((0, envFileSecrets_1.extractSecretLines)(document.getText(), document.uri.fsPath).map(secret => [secret.lineNumber, secret]))
+            : new Map();
+        const nornenvConfig = isNornenvFile ? (0, environmentParser_1.parseEnvFile)(document.getText(), document.uri.fsPath) : undefined;
+        // Region-pattern refactor — single top-of-file lens when a flat S × R matrix is detected.
+        if (isNornenvFile && nornenvConfig) {
+            const pattern = (0, nornenvRegionRefactor_1.detectRegionPattern)(nornenvConfig, document.getText());
+            if (pattern) {
+                const { liftedToStage, liftedToRegion, leafSpecific } = pattern.summary;
+                const topRange = new vscode.Range(0, 0, 0, 0);
+                codeLenses.push(new vscode.CodeLens(topRange, {
+                    title: `$(sparkle) Refactor ${pattern.cells.length} envs into ${pattern.stages.length}+${pattern.regions.length} templates`,
+                    command: 'norn.nornenv.refactorRegionPattern',
+                    arguments: [document.uri.fsPath],
+                    tooltip: `Detected an S × R pattern (${pattern.stages.join(', ')} × ${pattern.regions.join(', ')}). `
+                        + `Refactor will lift ${liftedToStage} vars to stage templates, ${liftedToRegion} to region templates, and keep ${leafSpecific} as leaf-specific.`
+                }));
+            }
+        }
+        // Track if we're inside a sequence
+        let insideSequence = false;
+        for (let i = 0; i < document.lineCount; i++) {
+            const line = document.lineAt(i);
+            const trimmedText = line.text.trim();
+            if (isNornenvFile) {
+                const headerMatch = trimmedText.match(/^\[env:([a-zA-Z_][a-zA-Z0-9_-]*)(?:\s+extends\s+([^\]]+))?\]\s*$/i);
+                if (headerMatch) {
+                    const envName = headerMatch[1];
+                    const parents = (headerMatch[2] ?? '')
+                        .split(',')
+                        .map(parent => parent.trim())
+                        .filter(parent => parent.length > 0);
+                    const range = new vscode.Range(i, 0, i, line.text.length);
+                    const activeEnv = (0, environmentProvider_1.getActiveEnvironment)(document.uri.fsPath);
+                    if (activeEnv !== envName) {
+                        codeLenses.push(new vscode.CodeLens(range, {
+                            title: '$(debug-start) Activate',
+                            command: 'norn.nornenv.activate',
+                            arguments: [envName, document.uri.fsPath],
+                            tooltip: `Use '${envName}' as the active Norn environment`
+                        }));
+                    }
+                    if (parents.length > 0) {
+                        const inheritedCount = nornenvConfig
+                            ? (0, environmentParser_1.resolveInheritedVariableDetails)(envName, nornenvConfig).size
+                            : 0;
+                        codeLenses.push(new vscode.CodeLens(range, {
+                            title: `$(list-tree) Peek inherited (${inheritedCount})`,
+                            command: 'norn.nornenv.peekInherited',
+                            arguments: [envName, document.uri.fsPath],
+                            tooltip: `Show variables inherited by '${envName}'`
+                        }));
+                    }
+                    continue;
+                }
+                const secret = secretLinesByNumber.get(i);
+                if (!secret) {
+                    continue;
+                }
+                const range = new vscode.Range(i, 0, i, line.text.length);
+                if (!secret.encrypted) {
+                    codeLenses.push(new vscode.CodeLens(range, {
+                        title: '$(lock) Encrypt Secret',
+                        command: 'norn.encryptSecretAtLine',
+                        arguments: [document.uri.fsPath, i],
+                        tooltip: 'Encrypt this secret in-place'
+                    }));
+                    continue;
+                }
+                const parsed = (0, crypto_1.parseEncryptedSecretValue)(secret.value);
+                const hasValidCiphertext = parsed.ok;
+                codeLenses.push(new vscode.CodeLens(range, {
+                    title: '$(eye) View Decrypted',
+                    command: 'norn.viewDecryptedSecretAtLine',
+                    arguments: [document.uri.fsPath, i],
+                    tooltip: 'Reveal decrypted value in a temporary editor'
+                }));
+                codeLenses.push(new vscode.CodeLens(range, {
+                    title: '$(sync) Rotate Secret',
+                    command: 'norn.rotateSecretAtLine',
+                    arguments: [document.uri.fsPath, i],
+                    tooltip: hasValidCiphertext
+                        ? 'Replace with a new encrypted value'
+                        : 'Replace malformed secret with a new encrypted value'
+                }));
+                codeLenses.push(new vscode.CodeLens(range, {
+                    title: '$(trash) Delete Secret',
+                    command: 'norn.deleteSecretAtLine',
+                    arguments: [document.uri.fsPath, i],
+                    tooltip: 'Remove this secret declaration line'
+                }));
+                continue;
+            }
+            // Check for swagger statement (only in .nornapi files)
+            if (isNornApiFile) {
+                const swaggerMatch = trimmedText.match(swaggerRegex);
+                if (swaggerMatch) {
+                    const range = new vscode.Range(i, 0, i, line.text.length);
+                    codeLenses.push(new vscode.CodeLens(range, {
+                        title: '$(debug-start)   Import Endpoints',
+                        command: 'norn.importSwagger',
+                        arguments: [swaggerMatch[1], i],
+                        tooltip: `Parse OpenAPI spec and generate endpoints`
+                    }));
+                    // Add Generate Schemas CodeLens
+                    codeLenses.push(new vscode.CodeLens(range, {
+                        title: '$(file-code) Generate Schemas',
+                        command: 'norn.generateSchemasFromSwagger',
+                        arguments: [swaggerMatch[1], document.uri.fsPath],
+                        tooltip: 'Generate JSON Schema files from OpenAPI response definitions'
+                    }));
+                    // Add file-scoped coverage CodeLens
+                    codeLenses.push(new vscode.CodeLens(range, {
+                        title: '$(graph) Show Coverage',
+                        command: 'norn.showCoverage',
+                        arguments: [document.uri.fsPath],
+                        tooltip: 'Show API coverage for this .nornapi file (includes this folder and subfolders only).'
+                    }));
+                    continue;
+                }
+            }
+            // Check for matchesSchema assertions (in .norn files)
+            if (isNornFile) {
+                const schemaMatch = trimmedText.match(matchesSchemaRegex);
+                if (schemaMatch) {
+                    const schemaPath = schemaMatch[1];
+                    const range = new vscode.Range(i, 0, i, line.text.length);
+                    // Open Contract lens
+                    codeLenses.push(new vscode.CodeLens(range, {
+                        title: '$(file-code) Open Contract',
+                        command: 'norn.openSchemaFile',
+                        arguments: [schemaPath, document.uri.fsPath],
+                        tooltip: `Open schema file: ${schemaPath}`
+                    }));
+                    // View Contract Report lens
+                    codeLenses.push(new vscode.CodeLens(range, {
+                        title: '$(checklist) View Contract',
+                        command: 'norn.viewContractReport',
+                        arguments: [i, document.uri.fsPath, schemaPath],
+                        tooltip: 'Run validation and show contract comparison report'
+                    }));
+                    continue;
+                }
+            }
+            // Check for sequence start
+            const sequenceMatch = trimmedText.match(sequenceRegex);
+            if (sequenceMatch) {
+                insideSequence = true;
+                const range = new vscode.Range(i, 0, i, line.text.length);
+                // Show Run Sequence if parameters are all optional, or values are provided via @data/@theory.
+                const canRunWithoutArgs = canRunSequenceWithoutArgs(trimmedText);
+                const hasTheoryAnnotations = hasTheoryAnnotationsAbove(document, i);
+                if (canRunWithoutArgs || hasTheoryAnnotations) {
+                    // Run Sequence lens
+                    codeLenses.push(new vscode.CodeLens(range, {
+                        title: '▶ Run Sequence',
+                        command: 'norn.runSequence',
+                        arguments: [i],
+                        tooltip: `Run all requests in sequence "${sequenceMatch[1]}"`
+                    }));
+                    // Debug Sequence lens
+                    codeLenses.push(new vscode.CodeLens(range, {
+                        title: '▷ Debug Sequence',
+                        command: 'norn.debugSequence',
+                        arguments: [i, document.uri.fsPath, sequenceMatch[1]],
+                        tooltip: `Debug sequence "${sequenceMatch[1]}" with breakpoints and stepping`
+                    }));
+                    // Environment lens
+                    codeLenses.push(new vscode.CodeLens(range, {
+                        title: envInfo.text,
+                        command: envInfo.hasEnvFile ? 'norn.selectEnvironmentAndRefresh' : 'norn.createEnvFile',
+                        arguments: envInfo.hasEnvFile ? [document.uri.fsPath] : undefined,
+                        tooltip: envInfo.hasEnvFile ? 'Click to change environment' : 'Click to create .nornenv file'
+                    }));
+                }
+                continue;
+            }
+            // Check for sequence end
+            if (trimmedText === 'end sequence') {
+                insideSequence = false;
+                continue;
+            }
+            // Only show "Send Request" for requests OUTSIDE of sequences
+            if (!insideSequence && methodRegex.test(line.text)) {
+                const range = new vscode.Range(i, 0, i, line.text.length);
+                // Send Request lens
+                codeLenses.push(new vscode.CodeLens(range, {
+                    title: '▶ Send Request',
+                    command: 'norn.sendRequest',
+                    arguments: [i],
+                    tooltip: 'Send this HTTP request'
+                }));
+                // Environment lens
+                codeLenses.push(new vscode.CodeLens(range, {
+                    title: envInfo.text,
+                    command: envInfo.hasEnvFile ? 'norn.selectEnvironmentAndRefresh' : 'norn.createEnvFile',
+                    arguments: envInfo.hasEnvFile ? [document.uri.fsPath] : undefined,
+                    tooltip: envInfo.hasEnvFile ? 'Click to change environment' : 'Click to create .nornenv file'
+                }));
+            }
+        }
+        return codeLenses;
+    }
+}
+exports.HttpCodeLensProvider = HttpCodeLensProvider;
+//# sourceMappingURL=codeLensProvider.js.map