norn-cli 1.3.16 → 1.3.18

package/out/diagnosticProvider.js

@@ -0,0 +1,980 @@
+"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.DiagnosticProvider = void 0;
+const vscode = __importStar(require("vscode"));
+const path = __importStar(require("path"));
+const fs = __importStar(require("fs"));
+const parser_1 = require("./parser");
+const sequenceRunner_1 = require("./sequenceRunner");
+const environmentProvider_1 = require("./environmentProvider");
+const nornapiParser_1 = require("./nornapiParser");
+/**
+ * Extracts variables defined within a specific sequence, including:
+ * - var statements
+ * - var x = run Sequence (capture from returned sequences)
+ * - Response captures (var x = $1.body)
+ * - Sequence parameters (from the sequence declaration)
+ */
+function getSequenceLocalVariables(sequenceContent, parameters) {
+    const vars = new Set();
+    // Add sequence parameters as local variables
+    if (parameters) {
+        for (const param of parameters) {
+            vars.add(param.name);
+        }
+    }
+    const lines = sequenceContent.split('\n');
+    for (const line of lines) {
+        const trimmed = line.trim();
+        // Match any var assignment
+        const varMatch = trimmed.match(/^var\s+([a-zA-Z_][a-zA-Z0-9_]*)\s*=/);
+        if (varMatch) {
+            vars.add(varMatch[1]);
+        }
+    }
+    return vars;
+}
+/**
+ * Check if a line is a comment (starts with #)
+ */
+function isCommentLine(line) {
+    return line.trim().startsWith('#');
+}
+/**
+ * Strip inline comment from a line.
+ * Finds # that is not inside quotes and removes everything after it.
+ */
+function stripInlineComment(line) {
+    let inSingleQuote = false;
+    let inDoubleQuote = false;
+    for (let i = 0; i < line.length; i++) {
+        const char = line[i];
+        const prevChar = i > 0 ? line[i - 1] : '';
+        // Skip escaped quotes
+        if (prevChar === '\\') {
+            continue;
+        }
+        if (char === '"' && !inSingleQuote) {
+            inDoubleQuote = !inDoubleQuote;
+        }
+        else if (char === "'" && !inDoubleQuote) {
+            inSingleQuote = !inSingleQuote;
+        }
+        else if (char === '#' && !inSingleQuote && !inDoubleQuote) {
+            // Found an unquoted #, strip from here
+            return line.substring(0, i).trimEnd();
+        }
+    }
+    return line;
+}
+/**
+ * Tokenize print statement content into individual tokens.
+ * Respects quoted strings and splits on operators/whitespace.
+ */
+function tokenizePrintContent(content) {
+    const tokens = [];
+    let current = '';
+    let currentStart = 0;
+    let inString = false;
+    let stringChar = '';
+    let i = 0;
+    const pushToken = () => {
+        if (current.trim()) {
+            tokens.push({ text: current.trim(), start: currentStart + (current.length - current.trimStart().length) });
+        }
+        current = '';
+    };
+    while (i < content.length) {
+        const char = content[i];
+        if (inString) {
+            current += char;
+            if (char === stringChar && content[i - 1] !== '\\') {
+                inString = false;
+                pushToken();
+            }
+            i++;
+            continue;
+        }
+        // Start of string
+        if (char === '"' || char === "'") {
+            pushToken();
+            inString = true;
+            stringChar = char;
+            current = char;
+            currentStart = i;
+            i++;
+            continue;
+        }
+        // Operators and whitespace are delimiters
+        if (/[\s+\-*/|&<>=!]/.test(char)) {
+            pushToken();
+            // If it's an operator, add it as its own token
+            if (/[+\-*/|&<>=!]/.test(char)) {
+                tokens.push({ text: char, start: i });
+            }
+            currentStart = i + 1;
+            i++;
+            continue;
+        }
+        // Regular character
+        if (current === '') {
+            currentStart = i;
+        }
+        current += char;
+        i++;
+    }
+    // Push any remaining token
+    pushToken();
+    return tokens;
+}
+class DiagnosticProvider {
+    diagnosticCollection;
+    constructor() {
+        this.diagnosticCollection = vscode.languages.createDiagnosticCollection('norn');
+    }
+    updateDiagnostics(document) {
+        if (document.languageId === 'nornenv') {
+            this.updateNornenvDiagnostics(document);
+            return;
+        }
+        if (document.languageId === 'nornapi') {
+            this.updateNornapiDiagnostics(document);
+            return;
+        }
+        if (document.languageId !== 'norn') {
+            return;
+        }
+        const diagnostics = [];
+        const text = document.getText();
+        // Extract file-level variables (outside sequences) + environment
+        const fileLevelVariables = (0, parser_1.extractFileLevelVariables)(text);
+        const envVariables = (0, environmentProvider_1.getEnvironmentVariables)();
+        const globalVariables = { ...envVariables, ...fileLevelVariables };
+        // Extract sequences for scope-aware checking
+        const sequences = (0, sequenceRunner_1.extractSequences)(text);
+        const lines = text.split('\n');
+        // Check for duplicate sequence declarations
+        const declaredSequences = new Map(); // seqName -> first declaration line
+        for (const seq of sequences) {
+            if (declaredSequences.has(seq.name)) {
+                const firstLine = declaredSequences.get(seq.name);
+                const line = lines[seq.startLine];
+                // Find the sequence name position in the line
+                const nameStart = line.indexOf(seq.name);
+                const range = new vscode.Range(new vscode.Position(seq.startLine, nameStart), new vscode.Position(seq.startLine, nameStart + seq.name.length));
+                const diagnostic = new vscode.Diagnostic(range, `Duplicate sequence: '${seq.name}' is already declared on line ${firstLine + 1}.`, vscode.DiagnosticSeverity.Error);
+                diagnostic.source = 'Norn';
+                diagnostic.code = 'duplicate-sequence';
+                diagnostics.push(diagnostic);
+            }
+            else {
+                declaredSequences.set(seq.name, seq.startLine);
+            }
+        }
+        // Check for duplicate variable declarations at file level (outside sequences)
+        const varDeclRegex = /^\s*var\s+([a-zA-Z_][a-zA-Z0-9_]*)\s*=/;
+        const declaredVars = new Map(); // varName -> first declaration line
+        for (let i = 0; i < lines.length; i++) {
+            const line = lines[i];
+            // Skip comment lines
+            if (isCommentLine(line)) {
+                continue;
+            }
+            // Check if this line is inside a sequence (skip sequence-local vars)
+            const isInsideSequence = sequences.some(seq => i > seq.startLine && i < seq.endLine);
+            if (isInsideSequence) {
+                continue;
+            }
+            const lineWithoutComment = stripInlineComment(line);
+            const varMatch = lineWithoutComment.match(varDeclRegex);
+            if (varMatch) {
+                const varName = varMatch[1];
+                if (declaredVars.has(varName)) {
+                    const firstLine = declaredVars.get(varName);
+                    const startCol = line.indexOf(varName);
+                    const range = new vscode.Range(new vscode.Position(i, startCol), new vscode.Position(i, startCol + varName.length));
+                    const diagnostic = new vscode.Diagnostic(range, `Duplicate variable declaration: '${varName}' is already declared on line ${firstLine + 1}.`, vscode.DiagnosticSeverity.Error);
+                    diagnostic.source = 'Norn';
+                    diagnostic.code = 'duplicate-variable';
+                    diagnostics.push(diagnostic);
+                }
+                else {
+                    declaredVars.set(varName, i);
+                }
+            }
+        }
+        // Check for invalid named request declarations (names with spaces) and duplicates
+        const invalidNameRegex = /^\s*\[(?:Name:\s*)?(.+)\]\s*$/;
+        const namedRequestRegex = /^\s*\[(?:Name:\s*)?([a-zA-Z_][a-zA-Z0-9_-]*)\]/;
+        const validNameRegex = /^[a-zA-Z_][a-zA-Z0-9_-]*$/;
+        const declaredNamedRequests = new Map(); // name -> first declaration line
+        for (let i = 0; i < lines.length; i++) {
+            const line = lines[i];
+            // Skip comment lines
+            if (isCommentLine(line)) {
+                continue;
+            }
+            // Strip inline comments before checking
+            const lineWithoutComment = stripInlineComment(line);
+            // Check for valid named request and track for duplicates
+            const namedMatch = lineWithoutComment.match(namedRequestRegex);
+            if (namedMatch) {
+                const name = namedMatch[1];
+                if (declaredNamedRequests.has(name)) {
+                    const firstLine = declaredNamedRequests.get(name);
+                    const startCol = line.indexOf('[');
+                    const endCol = line.indexOf(']') + 1;
+                    const range = new vscode.Range(new vscode.Position(i, startCol), new vscode.Position(i, endCol));
+                    const diagnostic = new vscode.Diagnostic(range, `Duplicate named request: '${name}' is already declared on line ${firstLine + 1}.`, vscode.DiagnosticSeverity.Error);
+                    diagnostic.source = 'Norn';
+                    diagnostic.code = 'duplicate-named-request';
+                    diagnostics.push(diagnostic);
+                }
+                else {
+                    declaredNamedRequests.set(name, i);
+                }
+            }
+            // Check for invalid names (with spaces etc)
+            const match = lineWithoutComment.match(invalidNameRegex);
+            if (match) {
+                const name = match[1].trim();
+                if (!validNameRegex.test(name)) {
+                    const startCol = line.indexOf('[');
+                    const endCol = line.indexOf(']') + 1;
+                    const range = new vscode.Range(new vscode.Position(i, startCol), new vscode.Position(i, endCol));
+                    const diagnostic = new vscode.Diagnostic(range, `Invalid request name: '${name}'. Names cannot contain spaces and must start with a letter or underscore.`, vscode.DiagnosticSeverity.Error);
+                    diagnostic.source = 'Norn';
+                    diagnostic.code = 'invalid-request-name';
+                    diagnostics.push(diagnostic);
+                }
+            }
+        }
+        // Check for import statement errors
+        const imports = (0, parser_1.extractImports)(text);
+        const documentDir = path.dirname(document.uri.fsPath);
+        // Track imported names with source info for duplicate detection
+        // Maps name (lowercase) -> { sourcePath, lineNumber }
+        const importedRequests = new Map();
+        const importedSequences = new Map();
+        // Track imported API definitions (endpoints and header groups from .nornapi files)
+        // Maps name -> { sourcePath, lineNumber } to detect duplicates
+        const importedEndpoints = new Map();
+        const importedHeaderGroups = new Map();
+        for (const imp of imports) {
+            const absolutePath = path.resolve(documentDir, imp.path);
+            // Check if file exists
+            if (!fs.existsSync(absolutePath)) {
+                const line = lines[imp.lineNumber];
+                const startCol = line.indexOf(imp.path);
+                const range = new vscode.Range(new vscode.Position(imp.lineNumber, startCol), new vscode.Position(imp.lineNumber, startCol + imp.path.length));
+                const diagnostic = new vscode.Diagnostic(range, `Import file not found: '${imp.path}'`, vscode.DiagnosticSeverity.Error);
+                diagnostic.source = 'Norn';
+                diagnostic.code = 'import-not-found';
+                diagnostics.push(diagnostic);
+            }
+            else {
+                // Read the imported file and extract its named requests/sequences
+                try {
+                    const importedContent = fs.readFileSync(absolutePath, 'utf-8');
+                    // Check if this is a .nornapi file
+                    if (imp.path.endsWith('.nornapi')) {
+                        const apiDef = (0, nornapiParser_1.parseNornApiFile)(importedContent);
+                        for (const endpoint of apiDef.endpoints) {
+                            const existing = importedEndpoints.get(endpoint.name);
+                            if (existing) {
+                                // Duplicate endpoint found
+                                const line = lines[imp.lineNumber];
+                                const startCol = line.indexOf(imp.path);
+                                const range = new vscode.Range(new vscode.Position(imp.lineNumber, startCol), new vscode.Position(imp.lineNumber, startCol + imp.path.length));
+                                const diagnostic = new vscode.Diagnostic(range, `Duplicate endpoint '${endpoint.name}': already defined in '${existing.sourcePath}'`, vscode.DiagnosticSeverity.Error);
+                                diagnostic.source = 'Norn';
+                                diagnostic.code = 'duplicate-endpoint';
+                                diagnostics.push(diagnostic);
+                            }
+                            else {
+                                importedEndpoints.set(endpoint.name, { sourcePath: imp.path, lineNumber: imp.lineNumber });
+                            }
+                        }
+                        for (const group of apiDef.headerGroups) {
+                            const existing = importedHeaderGroups.get(group.name);
+                            if (existing) {
+                                // Duplicate header group found
+                                const line = lines[imp.lineNumber];
+                                const startCol = line.indexOf(imp.path);
+                                const range = new vscode.Range(new vscode.Position(imp.lineNumber, startCol), new vscode.Position(imp.lineNumber, startCol + imp.path.length));
+                                const diagnostic = new vscode.Diagnostic(range, `Duplicate header group '${group.name}': already defined in '${existing.sourcePath}'`, vscode.DiagnosticSeverity.Error);
+                                diagnostic.source = 'Norn';
+                                diagnostic.code = 'duplicate-header-group';
+                                diagnostics.push(diagnostic);
+                            }
+                            else {
+                                importedHeaderGroups.set(group.name, { sourcePath: imp.path, lineNumber: imp.lineNumber });
+                            }
+                        }
+                    }
+                    else {
+                        // Regular .norn file
+                        const fileRequests = (0, parser_1.extractNamedRequests)(importedContent);
+                        const fileSequences = (0, sequenceRunner_1.extractSequences)(importedContent);
+                        // Check for duplicate named requests
+                        for (const req of fileRequests) {
+                            const lowerName = req.name.toLowerCase();
+                            const existing = importedRequests.get(lowerName);
+                            if (existing) {
+                                const line = lines[imp.lineNumber];
+                                const startCol = line.indexOf(imp.path);
+                                const range = new vscode.Range(new vscode.Position(imp.lineNumber, startCol), new vscode.Position(imp.lineNumber, startCol + imp.path.length));
+                                const diagnostic = new vscode.Diagnostic(range, `Duplicate named request '${req.name}': already defined in '${existing.sourcePath}'`, vscode.DiagnosticSeverity.Error);
+                                diagnostic.source = 'Norn';
+                                diagnostic.code = 'duplicate-named-request-import';
+                                diagnostics.push(diagnostic);
+                            }
+                            else {
+                                importedRequests.set(lowerName, { sourcePath: imp.path, lineNumber: imp.lineNumber });
+                            }
+                        }
+                        // Check for duplicate sequences
+                        for (const seq of fileSequences) {
+                            const lowerName = seq.name.toLowerCase();
+                            const existing = importedSequences.get(lowerName);
+                            if (existing) {
+                                const line = lines[imp.lineNumber];
+                                const startCol = line.indexOf(imp.path);
+                                const range = new vscode.Range(new vscode.Position(imp.lineNumber, startCol), new vscode.Position(imp.lineNumber, startCol + imp.path.length));
+                                const diagnostic = new vscode.Diagnostic(range, `Duplicate sequence '${seq.name}': already defined in '${existing.sourcePath}'`, vscode.DiagnosticSeverity.Error);
+                                diagnostic.source = 'Norn';
+                                diagnostic.code = 'duplicate-sequence-import';
+                                diagnostics.push(diagnostic);
+                            }
+                            else {
+                                importedSequences.set(lowerName, { sourcePath: imp.path, lineNumber: imp.lineNumber });
+                            }
+                        }
+                    }
+                }
+                catch {
+                    // Ignore read errors - file exists but couldn't be read
+                }
+            }
+        }
+        // Check for misplaced tags/annotations.
+        // Any @decorator line must be directly associated with a following sequence declaration.
+        const tagPattern = /^\s*@([a-zA-Z_][a-zA-Z0-9_-]*)(?:\(([^)]*)\))?/;
+        const sequencePattern = /^\s*(?:test\s+)?sequence\s+[a-zA-Z_][a-zA-Z0-9_-]*/;
+        for (let i = 0; i < lines.length; i++) {
+            const line = lines[i];
+            // Skip comment lines
+            if (isCommentLine(line)) {
+                continue;
+            }
+            // Check if this line contains a tag/annotation decorator
+            if (tagPattern.test(line)) {
+                // Look ahead to find what this decorator applies to
+                let foundSequence = false;
+                let j = i + 1;
+                // Skip empty lines and additional decorator lines
+                while (j < lines.length) {
+                    const nextLine = lines[j].trim();
+                    if (!nextLine) {
+                        j++;
+                        continue;
+                    }
+                    if (tagPattern.test(nextLine)) {
+                        j++;
+                        continue;
+                    }
+                    if (sequencePattern.test(nextLine)) {
+                        foundSequence = true;
+                    }
+                    break;
+                }
+                const tagMatch = line.match(/@([a-zA-Z_][a-zA-Z0-9_-]*)(?:\([^)]+\))?/);
+                if (tagMatch) {
+                    const startCol = line.indexOf('@');
+                    const range = new vscode.Range(new vscode.Position(i, startCol), new vscode.Position(i, startCol + tagMatch[0].length));
+                    if (!foundSequence) {
+                        const annotationName = tagMatch[1];
+                        const isDataAnnotation = annotationName === 'data' || annotationName === 'theory';
+                        const message = isDataAnnotation
+                            ? `@${annotationName} must be placed immediately before a sequence declaration.`
+                            : `Tags must be placed immediately before a sequence declaration.`;
+                        const diagnostic = new vscode.Diagnostic(range, message, vscode.DiagnosticSeverity.Error);
+                        diagnostic.source = 'Norn';
+                        diagnostic.code = 'misplaced-tag';
+                        diagnostics.push(diagnostic);
+                    }
+                }
+            }
+        }
+        // Check for test sequences with required parameters but no @data/@theory
+        for (const seq of sequences) {
+            if (seq.isTest) {
+                const requiredParams = seq.parameters.filter(p => p.defaultValue === undefined);
+                if (requiredParams.length > 0 && !seq.theoryData) {
+                    // Find the line with the 'test sequence' declaration
+                    let declarationLine = seq.startLine;
+                    for (let i = seq.startLine; i <= seq.endLine; i++) {
+                        if (/^\s*test\s+sequence\s+/.test(lines[i])) {
+                            declarationLine = i;
+                            break;
+                        }
+                    }
+                    const line = lines[declarationLine];
+                    const startCol = line.indexOf('test');
+                    const endCol = line.length;
+                    const range = new vscode.Range(new vscode.Position(declarationLine, startCol), new vscode.Position(declarationLine, endCol));
+                    const paramNames = requiredParams.map(p => p.name).join(', ');
+                    const diagnostic = new vscode.Diagnostic(range, `Test sequence '${seq.name}' has required parameters (${paramNames}) but no @data or @theory annotation. Add @data(...) or @theory("file.json") to provide test values.`, vscode.DiagnosticSeverity.Error);
+                    diagnostic.source = 'Norn';
+                    diagnostic.code = 'test-missing-data';
+                    diagnostics.push(diagnostic);
+                }
+            }
+        }
+        // Check for undefined named requests/sequences in 'run' commands
+        const namedRequests = (0, parser_1.extractNamedRequests)(text);
+        const namedRequestNames = new Set(namedRequests.map(r => r.name.toLowerCase()));
+        const sequenceNames = new Set(sequences.map(s => s.name.toLowerCase()));
+        // Build a map of sequence name -> required parameter count
+        const sequenceParamInfo = new Map();
+        for (const seq of sequences) {
+            const requiredParams = seq.parameters.filter(p => p.defaultValue === undefined).length;
+            sequenceParamInfo.set(seq.name.toLowerCase(), { required: requiredParams, total: seq.parameters.length });
+        }
+        // Updated regex to capture optional arguments: run Name or run Name(args)
+        const runCommandRegex = /^\s*(?:var\s+[a-zA-Z_][a-zA-Z0-9_]*\s*=\s*)?run\s+([a-zA-Z_][a-zA-Z0-9_-]*)(?:\(([^)]*)\))?\s*$/;
+        for (let i = 0; i < lines.length; i++) {
+            const line = lines[i];
+            // Skip comment lines
+            if (isCommentLine(line)) {
+                continue;
+            }
+            const match = line.match(runCommandRegex);
+            if (match) {
+                const requestName = match[1];
+                const argsStr = match[2]; // undefined if no parens, empty string if (), or "arg1, arg2"
+                const lowerName = requestName.toLowerCase();
+                // Skip if it's a script command
+                if (['bash', 'js', 'powershell'].includes(lowerName)) {
+                    continue;
+                }
+                // Check if it's a local named request, local sequence, or imported
+                const isLocalRequest = namedRequestNames.has(lowerName);
+                const isLocalSequence = sequenceNames.has(lowerName);
+                const isImportedRequest = importedRequests.has(lowerName);
+                const isImportedSequence = importedSequences.has(lowerName);
+                if (!isLocalRequest && !isLocalSequence && !isImportedRequest && !isImportedSequence) {
+                    const startCol = line.indexOf(requestName);
+                    const range = new vscode.Range(new vscode.Position(i, startCol), new vscode.Position(i, startCol + requestName.length));
+                    const diagnostic = new vscode.Diagnostic(range, `Undefined request or sequence: '${requestName}'`, vscode.DiagnosticSeverity.Error);
+                    diagnostic.source = 'Norn';
+                    diagnostic.code = 'undefined-request';
+                    diagnostics.push(diagnostic);
+                }
+                else if (isLocalSequence) {
+                    // Check if sequence requires parameters but none were provided
+                    const paramInfo = sequenceParamInfo.get(lowerName);
+                    if (paramInfo && paramInfo.required > 0) {
+                        // Count provided arguments
+                        let providedCount = 0;
+                        if (argsStr !== undefined && argsStr.trim() !== '') {
+                            // Split by comma, but respect quoted strings
+                            const args = argsStr.split(',').map(a => a.trim()).filter(a => a !== '');
+                            providedCount = args.length;
+                        }
+                        if (providedCount < paramInfo.required) {
+                            const startCol = line.indexOf(requestName);
+                            const range = new vscode.Range(new vscode.Position(i, startCol), new vscode.Position(i, startCol + requestName.length));
+                            const seq = sequences.find(s => s.name.toLowerCase() === lowerName);
+                            const requiredParamNames = seq ?
+                                seq.parameters.filter(p => p.defaultValue === undefined).map(p => p.name).join(', ') :
+                                '';
+                            const diagnostic = new vscode.Diagnostic(range, `Sequence '${requestName}' requires ${paramInfo.required} parameter(s): ${requiredParamNames}`, vscode.DiagnosticSeverity.Error);
+                            diagnostic.source = 'Norn';
+                            diagnostic.code = 'missing-sequence-parameters';
+                            diagnostics.push(diagnostic);
+                        }
+                    }
+                }
+            }
+        }
+        // Check for undefined API endpoints and header groups
+        // Match patterns like: GET EndpointName("arg") HeaderGroup
+        const apiRequestRegex = /^\s*(GET|POST|PUT|DELETE|PATCH|HEAD|OPTIONS)\s+([A-Z][a-zA-Z0-9_]*)(?:\([^)]*\))?(?:\s+([A-Z][a-zA-Z0-9_]*))?/;
+        // Match standalone header group on its own line (after an API request)
+        const standaloneHeaderGroupRegex = /^\s+([A-Z][a-zA-Z0-9_]*)\s*$/;
+        for (let i = 0; i < lines.length; i++) {
+            const line = lines[i];
+            // Skip comment lines
+            if (isCommentLine(line)) {
+                continue;
+            }
+            // Strip inline comments before checking API request syntax
+            const lineWithoutComment = stripInlineComment(line);
+            // Check API request syntax
+            const apiMatch = lineWithoutComment.match(apiRequestRegex);
+            if (apiMatch) {
+                const endpointName = apiMatch[2];
+                const headerGroupName = apiMatch[3];
+                // Check if endpoint exists
+                if (!importedEndpoints.has(endpointName)) {
+                    const startCol = line.indexOf(endpointName);
+                    const range = new vscode.Range(new vscode.Position(i, startCol), new vscode.Position(i, startCol + endpointName.length));
+                    const diagnostic = new vscode.Diagnostic(range, `Undefined endpoint: '${endpointName}'. Import a .nornapi file that defines this endpoint.`, vscode.DiagnosticSeverity.Error);
+                    diagnostic.source = 'Norn';
+                    diagnostic.code = 'undefined-endpoint';
+                    diagnostics.push(diagnostic);
+                }
+                // Check if header group exists (if specified)
+                if (headerGroupName && !importedHeaderGroups.has(headerGroupName)) {
+                    const startCol = line.lastIndexOf(headerGroupName);
+                    const range = new vscode.Range(new vscode.Position(i, startCol), new vscode.Position(i, startCol + headerGroupName.length));
+                    const diagnostic = new vscode.Diagnostic(range, `Undefined header group: '${headerGroupName}'. Import a .nornapi file that defines this header group.`, vscode.DiagnosticSeverity.Error);
+                    diagnostic.source = 'Norn';
+                    diagnostic.code = 'undefined-header-group';
+                    diagnostics.push(diagnostic);
+                }
+            }
+            // Check standalone header group lines (indented, capitalized identifier only)
+            const standaloneMatch = lineWithoutComment.match(standaloneHeaderGroupRegex);
+            if (standaloneMatch) {
+                const headerGroupName = standaloneMatch[1];
+                // Only flag as undefined if we have some .nornapi imports (otherwise it might just be a typo or URL)
+                if (importedEndpoints.size > 0 || importedHeaderGroups.size > 0) {
+                    if (!importedHeaderGroups.has(headerGroupName)) {
+                        const startCol = line.indexOf(headerGroupName);
+                        const range = new vscode.Range(new vscode.Position(i, startCol), new vscode.Position(i, startCol + headerGroupName.length));
+                        const diagnostic = new vscode.Diagnostic(range, `Undefined header group: '${headerGroupName}'. Import a .nornapi file that defines this header group.`, vscode.DiagnosticSeverity.Error);
+                        diagnostic.source = 'Norn';
+                        diagnostic.code = 'undefined-header-group';
+                        diagnostics.push(diagnostic);
+                    }
+                }
+            }
+        }
+        // Find empty variable references {{}} or {{ }}
+        const emptyVarRegex = /\{\{\s*\}\}/g;
+        let emptyMatch;
+        while ((emptyMatch = emptyVarRegex.exec(text)) !== null) {
+            const startPos = document.positionAt(emptyMatch.index);
+            const endPos = document.positionAt(emptyMatch.index + emptyMatch[0].length);
+            const range = new vscode.Range(startPos, endPos);
+            const diagnostic = new vscode.Diagnostic(range, `Empty variable reference`, vscode.DiagnosticSeverity.Error);
+            diagnostic.source = 'Norn';
+            diagnostic.code = 'empty-variable';
+            diagnostics.push(diagnostic);
+        }
+        // Check for invalid variable assignments inside sequences
+        // Valid patterns:
+        // - var x = "string"  (quoted string)
+        // - var x = 123  (number)
+        // - var x = true/false/null  (literals)
+        // - var x = varName.path  (existing variable path)
+        // - var x = $1.body.id  (response capture)
+        // - var x = run ...  (script/json command)
+        // - var x = https://... (URL - for backward compat outside sequences)
+        const varAssignRegex = /^\s*var\s+([a-zA-Z_][a-zA-Z0-9_]*)\s*=\s*(.+)$/;
+        for (let i = 0; i < lines.length; i++) {
+            const line = lines[i];
+            // Skip comment lines
+            if (isCommentLine(line)) {
+                continue;
+            }
+            // Strip inline comments before processing
+            const lineWithoutComment = stripInlineComment(line);
+            const match = lineWithoutComment.match(varAssignRegex);
+            if (match) {
+                const varName = match[1];
+                const valueExpr = match[2].trim();
+                // Skip valid patterns
+                // 1. Response capture: $1.path
+                if (/^\$\d+/.test(valueExpr)) {
+                    continue;
+                }
+                // 2. Run command: run bash, run js, run powershell, run readJson
+                if (/^run\s+/i.test(valueExpr)) {
+                    continue;
+                }
+                // 3. Quoted string: "..." or '...'
+                if ((valueExpr.startsWith('"') && valueExpr.endsWith('"')) ||
+                    (valueExpr.startsWith("'") && valueExpr.endsWith("'"))) {
+                    continue;
+                }
+                // 4. Number
+                if (/^-?\d+(\.\d+)?$/.test(valueExpr)) {
+                    continue;
+                }
+                // 5. Boolean/null
+                if (/^(true|false|null)$/i.test(valueExpr)) {
+                    continue;
+                }
+                // 6. URL (common case outside sequences)
+                if (/^https?:\/\//.test(valueExpr)) {
+                    continue;
+                }
+                // 7. HTTP request: GET/POST/etc followed by URL or endpoint
+                const httpRequestMatch = valueExpr.match(/^(GET|POST|PUT|DELETE|PATCH|HEAD|OPTIONS)\s+(.+)$/i);
+                if (httpRequestMatch) {
+                    const afterMethod = httpRequestMatch[2].trim();
+                    // Check if it's a URL (starts with http, https, or {{ - also handle quoted URLs)
+                    if (/^["']?(https?:\/\/|\{\{)/.test(afterMethod)) {
+                        // It's a URL - skip validation
+                        continue;
+                    }
+                    // It might be an endpoint name: EndpointName(params) HeaderGroup1 HeaderGroup2
+                    const endpointMatch = afterMethod.match(/^([a-zA-Z_][a-zA-Z0-9_]*)(?:\([^)]*\))?(.*)$/);
+                    if (endpointMatch) {
+                        const endpointName = endpointMatch[1];
+                        const afterEndpoint = endpointMatch[2]?.trim() || '';
+                        // Validate endpoint exists
+                        if (importedEndpoints.size > 0 && !importedEndpoints.has(endpointName)) {
+                            const endpointStart = line.indexOf(endpointName, line.indexOf('='));
+                            const range = new vscode.Range(new vscode.Position(i, endpointStart), new vscode.Position(i, endpointStart + endpointName.length));
+                            diagnostics.push(new vscode.Diagnostic(range, `Undefined endpoint: '${endpointName}'. Import a .nornapi file that defines this endpoint.`, vscode.DiagnosticSeverity.Error));
+                        }
+                        // Validate header groups
+                        if (afterEndpoint) {
+                            // Strip retry and backoff options before checking header groups
+                            // Use \b word boundaries instead of \s+ since afterEndpoint is already trimmed
+                            const afterEndpointClean = afterEndpoint
+                                .replace(/\bretry\s+\d+/gi, '')
+                                .replace(/\bbackoff\s+\d+(?:\.\d+)?\s*(?:s|ms|seconds?|milliseconds?)?/gi, '');
+                            const headerGroupNames = afterEndpointClean.split(/\s+/).filter(n => n);
+                            for (const hgName of headerGroupNames) {
+                                if (!importedHeaderGroups.has(hgName)) {
+                                    const hgStart = line.lastIndexOf(hgName);
+                                    const range = new vscode.Range(new vscode.Position(i, hgStart), new vscode.Position(i, hgStart + hgName.length));
+                                    diagnostics.push(new vscode.Diagnostic(range, `Undefined header group: '${hgName}'. Import a .nornapi file that defines this header group.`, vscode.DiagnosticSeverity.Error));
+                                }
+                            }
+                        }
+                    }
+                    continue;
+                }
+                // 8. Variable path: must be an existing variable
+                const varPathMatch = valueExpr.match(/^([a-zA-Z_][a-zA-Z0-9_]*)((?:\.[a-zA-Z_][a-zA-Z0-9_]*|\[\d+\])*)$/);
+                if (varPathMatch) {
+                    const refVarName = varPathMatch[1];
+                    // Check if this assignment is inside a sequence
+                    const containingSeq = sequences.find(seq => i > seq.startLine && i < seq.endLine);
+                    let isValid = false;
+                    if (containingSeq) {
+                        // Inside sequence: check global vars + local sequence vars + params
+                        const localVars = getSequenceLocalVariables(containingSeq.content, containingSeq.parameters);
+                        isValid = refVarName in globalVariables || localVars.has(refVarName);
+                    }
+                    else {
+                        // Outside sequences: only global variables
+                        isValid = refVarName in globalVariables;
+                    }
+                    if (isValid) {
+                        continue;
+                    }
+                    // Variable not defined - show error
+                    const valueStart = line.indexOf('=') + 1;
+                    const valueStartTrimmed = valueStart + (line.substring(valueStart).length - line.substring(valueStart).trimStart().length);
+                    const range = new vscode.Range(new vscode.Position(i, valueStartTrimmed), new vscode.Position(i, valueStartTrimmed + refVarName.length));
+                    const diagnostic = new vscode.Diagnostic(range, `Undefined variable: '${refVarName}'. Use quotes for string literals: var ${varName} = "${valueExpr}"`, vscode.DiagnosticSeverity.Error);
+                    diagnostic.source = 'Norn';
+                    diagnostic.code = 'undefined-var-reference';
+                    diagnostics.push(diagnostic);
+                    continue;
+                }
+                // If we get here, it's an invalid expression (has spaces, not quoted, not valid pattern)
+                const valueStart = line.indexOf('=') + 1;
+                const valueStartTrimmed = valueStart + (line.substring(valueStart).length - line.substring(valueStart).trimStart().length);
+                const range = new vscode.Range(new vscode.Position(i, valueStartTrimmed), new vscode.Position(i, line.length));
+                const diagnostic = new vscode.Diagnostic(range, `Invalid variable value. Use quotes for strings: var ${varName} = "${valueExpr}"`, vscode.DiagnosticSeverity.Error);
+                diagnostic.source = 'Norn';
+                diagnostic.code = 'invalid-var-value';
+                diagnostics.push(diagnostic);
+            }
+        }
+        // Find all variable references {{variableName}} or {{variableName.path}}
+        // Match simple refs and the base name of path refs
+        const variableRefRegex = /\{\{([a-zA-Z_][a-zA-Z0-9_]*)((?:\.[a-zA-Z_][a-zA-Z0-9_]*|\[\d+\])*)\}\}/g;
+        let match;
+        while ((match = variableRefRegex.exec(text)) !== null) {
+            const varName = match[1];
+            const startPos = document.positionAt(match.index);
+            const lineNumber = startPos.line;
+            // Skip if this line is a comment
+            if (isCommentLine(lines[lineNumber])) {
+                continue;
+            }
+            // Check if this reference is inside a sequence
+            const containingSequence = sequences.find(seq => lineNumber > seq.startLine && lineNumber < seq.endLine);
+            let isValid = false;
+            if (containingSequence) {
+                // Inside a sequence: check global vars + local sequence vars + params
+                const localVars = getSequenceLocalVariables(containingSequence.content, containingSequence.parameters);
+                isValid = varName in globalVariables || localVars.has(varName);
+            }
+            else {
+                // Outside sequences: only global variables are available
+                isValid = varName in globalVariables;
+            }
+            if (!isValid) {
+                const endPos = document.positionAt(match.index + match[0].length);
+                const range = new vscode.Range(startPos, endPos);
+                const diagnostic = new vscode.Diagnostic(range, `Undefined variable: '${varName}'`, vscode.DiagnosticSeverity.Error);
+                diagnostic.source = 'Norn';
+                diagnostic.code = 'undefined-variable';
+                diagnostics.push(diagnostic);
+            }
+        }
+        // Check for bare text in print statements that isn't a string, variable, or keyword
+        const printCommandRegex = /^\s*print\s+(.+)$/i;
+        const validKeywords = new Set(['true', 'false', 'null']);
+        for (let i = 0; i < lines.length; i++) {
+            const line = lines[i];
+            // Skip comment lines
+            if (isCommentLine(line)) {
+                continue;
+            }
+            // Strip inline comments before processing print statement
+            const lineWithoutComment = stripInlineComment(line);
+            const printMatch = lineWithoutComment.match(printCommandRegex);
+            if (!printMatch) {
+                continue;
+            }
+            const printContent = printMatch[1];
+            const printStartCol = line.indexOf(printContent);
+            // Check if this print is inside a sequence
+            const containingSeq = sequences.find(seq => i > seq.startLine && i < seq.endLine);
+            // Get available variables for this scope
+            let availableVars;
+            if (containingSeq) {
+                const localVars = getSequenceLocalVariables(containingSeq.content, containingSeq.parameters);
+                availableVars = new Set([...Object.keys(globalVariables), ...localVars]);
+            }
+            else {
+                availableVars = new Set(Object.keys(globalVariables));
+            }
+            // Parse print content into tokens (respecting quoted strings and operators)
+            const tokens = tokenizePrintContent(printContent);
+            // Check for missing concatenation operators between tokens
+            for (let t = 0; t < tokens.length - 1; t++) {
+                const currentToken = tokens[t];
+                const nextToken = tokens[t + 1];
+                // Skip if current token is an operator
+                if (/^[+\-*/|&<>=!]+$/.test(currentToken.text)) {
+                    continue;
+                }
+                // If next token is not an operator, we're missing concatenation
+                if (!/^[+\-*/|&<>=!]+$/.test(nextToken.text)) {
+                    // Calculate position between the two tokens
+                    const errorStartCol = printStartCol + currentToken.start + currentToken.text.length;
+                    const errorEndCol = printStartCol + nextToken.start;
+                    const range = new vscode.Range(new vscode.Position(i, errorStartCol), new vscode.Position(i, errorEndCol));
+                    const diagnostic = new vscode.Diagnostic(range, `Missing concatenation operator '+' between '${currentToken.text}' and '${nextToken.text}'`, vscode.DiagnosticSeverity.Error);
+                    diagnostic.source = 'Norn';
+                    diagnostic.code = 'missing-concatenation';
+                    diagnostics.push(diagnostic);
+                }
+            }
+            for (const token of tokens) {
+                // Skip operators (+, -, etc.)
+                if (/^[+\-*/|&<>=!]+$/.test(token.text)) {
+                    continue;
+                }
+                // Skip quoted strings
+                if ((token.text.startsWith('"') && token.text.endsWith('"')) ||
+                    (token.text.startsWith("'") && token.text.endsWith("'"))) {
+                    continue;
+                }
+                // Skip numbers
+                if (/^-?\d+(\.\d+)?$/.test(token.text)) {
+                    continue;
+                }
+                // Skip keywords (true, false, null)
+                if (validKeywords.has(token.text.toLowerCase())) {
+                    continue;
+                }
+                // Skip variable references {{var}}
+                if (/^\{\{.+\}\}$/.test(token.text)) {
+                    continue;
+                }
+                // Check if it's a valid variable (with optional path)
+                const varPathMatch = token.text.match(/^([a-zA-Z_][a-zA-Z0-9_]*)((?:\.[a-zA-Z_][a-zA-Z0-9_]*|\[\d+\])*)$/);
+                if (varPathMatch) {
+                    const refVarName = varPathMatch[1];
+                    if (availableVars.has(refVarName)) {
+                        continue;
+                    }
+                }
+                // Check if it looks like a plain text word (not a valid identifier pattern)
+                // Flag words that look like they should be quoted
+                if (/^[a-zA-Z_][a-zA-Z0-9_]*$/.test(token.text)) {
+                    // It's a valid identifier but not a defined variable - flag it
+                    const tokenStartCol = printStartCol + token.start;
+                    const range = new vscode.Range(new vscode.Position(i, tokenStartCol), new vscode.Position(i, tokenStartCol + token.text.length));
+                    const diagnostic = new vscode.Diagnostic(range, `Undefined variable: '${token.text}'. Use quotes for string literals: "${token.text}"`, vscode.DiagnosticSeverity.Error);
+                    diagnostic.source = 'Norn';
+                    diagnostic.code = 'undefined-print-variable';
+                    diagnostics.push(diagnostic);
+                }
+                else if (!/^[a-zA-Z_]/.test(token.text) === false && !varPathMatch) {
+                    // Some other bare text that doesn't look like anything valid
+                    const tokenStartCol = printStartCol + token.start;
+                    const range = new vscode.Range(new vscode.Position(i, tokenStartCol), new vscode.Position(i, tokenStartCol + token.text.length));
+                    const diagnostic = new vscode.Diagnostic(range, `Invalid expression: '${token.text}'. Use quotes for string literals.`, vscode.DiagnosticSeverity.Error);
+                    diagnostic.source = 'Norn';
+                    diagnostic.code = 'invalid-print-expression';
+                    diagnostics.push(diagnostic);
+                }
+            }
+        }
+        this.diagnosticCollection.set(document.uri, diagnostics);
+    }
+    /**
+     * Update diagnostics for .nornapi files
+     */
+    updateNornapiDiagnostics(document) {
+        const diagnostics = [];
+        const lines = document.getText().split('\n');
+        const httpMethods = ['GET', 'POST', 'PUT', 'DELETE', 'PATCH', 'HEAD', 'OPTIONS'];
+        let inEndpointsBlock = false;
+        for (let i = 0; i < lines.length; i++) {
+            const line = lines[i];
+            const trimmed = stripInlineComment(line).trim();
+            // Skip empty lines/comments
+            if (trimmed === '' || trimmed.startsWith('#')) {
+                continue;
+            }
+            // Track endpoints block state
+            if (/^endpoints$/i.test(trimmed)) {
+                inEndpointsBlock = true;
+                continue;
+            }
+            if (/^end\s+endpoints$/i.test(trimmed)) {
+                inEndpointsBlock = false;
+                continue;
+            }
+            if (!inEndpointsBlock) {
+                continue;
+            }
+            // Valid endpoint declaration: Name: METHOD path
+            const validEndpoint = trimmed.match(/^([a-zA-Z_][a-zA-Z0-9_]*)\s*:\s*(GET|POST|PUT|DELETE|PATCH|HEAD|OPTIONS)\s+(.+)$/i);
+            if (validEndpoint) {
+                continue;
+            }
+            const endpointMatch = trimmed.match(/^([a-zA-Z_][a-zA-Z0-9_]*)\s*:\s*(.*)$/);
+            if (!endpointMatch) {
+                continue;
+            }
+            const endpointName = endpointMatch[1];
+            const rhs = endpointMatch[2].trim();
+            const colonIndex = line.indexOf(':');
+            const valueStart = colonIndex >= 0 ? colonIndex + 1 : 0;
+            const valueRange = new vscode.Range(new vscode.Position(i, Math.max(0, valueStart)), new vscode.Position(i, line.length));
+            // While typing: "Name:" or "Name: G" should not error yet
+            if (rhs === '') {
+                continue;
+            }
+            const firstToken = rhs.split(/\s+/)[0];
+            const upperFirstToken = firstToken.toUpperCase();
+            const isPartialMethod = httpMethods.some(m => m.startsWith(upperFirstToken));
+            if (!rhs.includes(' ') && isPartialMethod) {
+                continue;
+            }
+            if (httpMethods.includes(upperFirstToken) && !rhs.includes(' ')) {
+                const diagnostic = new vscode.Diagnostic(valueRange, `Endpoint '${endpointName}' is missing a URL/path after method. Use: ${endpointName}: ${upperFirstToken} /path`, vscode.DiagnosticSeverity.Error);
+                diagnostic.source = 'Norn';
+                diagnostic.code = 'missing-endpoint-path';
+                diagnostics.push(diagnostic);
+                continue;
+            }
+            const diagnostic = new vscode.Diagnostic(valueRange, `Endpoint '${endpointName}' is missing HTTP method. Use: ${endpointName}: GET /path`, vscode.DiagnosticSeverity.Error);
+            diagnostic.source = 'Norn';
+            diagnostic.code = 'missing-endpoint-method';
+            diagnostics.push(diagnostic);
+        }
+        this.diagnosticCollection.set(document.uri, diagnostics);
+    }
+    /**
+     * Update diagnostics for .nornenv files
+     */
+    updateNornenvDiagnostics(document) {
+        const diagnostics = [];
+        const text = document.getText();
+        const lines = text.split('\n');
+        for (let i = 0; i < lines.length; i++) {
+            const line = lines[i];
+            const trimmed = line.trim();
+            // Skip comments and empty lines
+            if (trimmed === '' || trimmed.startsWith('#')) {
+                continue;
+            }
+            // Check for invalid "secret var" pattern
+            const secretVarMatch = trimmed.match(/^(secret)\s+(var)\s*/i);
+            if (secretVarMatch) {
+                const varStart = line.indexOf('var', line.indexOf('secret') + 6);
+                const range = new vscode.Range(new vscode.Position(i, varStart), new vscode.Position(i, varStart + 3));
+                const diagnostic = new vscode.Diagnostic(range, `Invalid syntax: 'var' is not allowed after 'secret'. Use 'secret variableName = value'.`, vscode.DiagnosticSeverity.Error);
+                diagnostic.source = 'Norn';
+                diagnostic.code = 'invalid-secret-var';
+                diagnostics.push(diagnostic);
+                continue;
+            }
+            // Check for valid patterns - if none match, it's an error
+            const validPatterns = [
+                /^\[env:[a-zA-Z_][a-zA-Z0-9_-]*\]$/, // Environment section
+                /^(secret|var)\s+[a-zA-Z_][a-zA-Z0-9_]*\s*=\s*.+$/, // Complete declaration
+                /^(secret|var)\s*$/, // Just keyword (while typing)
+                /^(secret|var)\s+[a-zA-Z_][a-zA-Z0-9_]*\s*$/, // Keyword + name (while typing)
+                /^(secret|var)\s+[a-zA-Z_][a-zA-Z0-9_]*\s*=\s*$/, // Keyword + name + = (while typing)
+            ];
+            const isValid = validPatterns.some(pattern => pattern.test(trimmed));
+            if (!isValid) {
+                const range = new vscode.Range(new vscode.Position(i, 0), new vscode.Position(i, line.length));
+                const diagnostic = new vscode.Diagnostic(range, `Invalid syntax. Expected: 'var name = value', 'secret name = value', or '[env:name]'.`, vscode.DiagnosticSeverity.Error);
+                diagnostic.source = 'Norn';
+                diagnostic.code = 'invalid-nornenv-syntax';
+                diagnostics.push(diagnostic);
+            }
+        }
+        this.diagnosticCollection.set(document.uri, diagnostics);
+    }
+    clearDiagnostics(document) {
+        this.diagnosticCollection.delete(document.uri);
+    }
+    dispose() {
+        this.diagnosticCollection.dispose();
+    }
+}
+exports.DiagnosticProvider = DiagnosticProvider;
+//# sourceMappingURL=diagnosticProvider.js.map