norn-cli 1.4.0 → 1.4.2

package/out/completionProvider.js

@@ -41,6 +41,7 @@ const parser_1 = require("./parser");
 const sequenceRunner_1 = require("./sequenceRunner");
 const environmentProvider_1 = require("./environmentProvider");
 const nornapiParser_1 = require("./nornapiParser");
+const swaggerBodyIntellisenseCache_1 = require("./swaggerBodyIntellisenseCache");
 class HttpCompletionProvider {
     httpMethods = ['GET', 'POST', 'PUT', 'DELETE', 'PATCH', 'HEAD', 'OPTIONS'];
     keywords = ['var', 'test', 'test sequence', 'sequence', 'end sequence', 'if', 'end if', 'wait', 'run bash', 'run powershell', 'run js', 'run readJson', 'run', 'print', 'assert', 'import', 'return', 'retry', 'backoff'];
@@ -140,15 +141,26 @@ class HttpCompletionProvider {
         if (this.isTypingPropertyAssignment(linePrefix)) {
             return this.getPropertyAssignmentCompletions(document, linePrefix);
         }
-        // Check if user might be typing a JSON variable name for property assignment
-        const jsonVarCompletions = this.getJsonVariableCompletions(document, linePrefix);
-        // If we have JSON variable completions, show those (for property assignment)
-        if (jsonVarCompletions.length > 0) {
-            return jsonVarCompletions;
+        // Swagger-based request body IntelliSense for endpoint POST/PUT/PATCH calls.
+        const requestBodyContext = this.getRequestBodyCompletionContext(document, position);
+        if (requestBodyContext) {
+            if (this.isTypingJsonBodyStart(linePrefix)) {
+                return this.getRequestBodyTemplateCompletions(requestBodyContext, position, lineText);
+            }
+            const inlineBodyCompletions = this.getInlineRequestBodyKeyCompletions(requestBodyContext, document, position, linePrefix);
+            if (inlineBodyCompletions.length > 0) {
+                return inlineBodyCompletions;
+            }
+        }
+        const isAfterApiRequest = this.isAfterApiRequest(document, position);
+        // If a JSON body is being started right below an API request, don't show IntelliSense.
+        // We don't know body shape, and header/group suggestions are noisy in this context.
+        if (isAfterApiRequest && this.isTypingJsonBodyStart(linePrefix)) {
+            return [];
         }
         // Check if we're after an API request (GET EndpointName, etc.)
         // Provide header groups and inline headers
-        if (this.isAfterApiRequest(document, position)) {
+        if (isAfterApiRequest) {
             // If typing a header name (no colon yet), provide both header groups and inline headers
             if (!linePrefix.includes(':')) {
                 const headerGroupCompletions = this.getStandaloneHeaderGroupCompletions(document, linePrefix);
@@ -158,6 +170,12 @@ class HttpCompletionProvider {
             // If line has a colon but not Content-Type (which is handled earlier), return empty
             return [];
         }
+        // Check if user might be typing a JSON variable name for property assignment
+        const jsonVarCompletions = this.getJsonVariableCompletions(document, linePrefix);
+        // If we have JSON variable completions, show those (for property assignment)
+        if (jsonVarCompletions.length > 0) {
+            return jsonVarCompletions;
+        }
         // Show HTTP methods/keywords at line start (or while typing them),
         // but not after a METHOD ... context where endpoint/header logic applies.
         if ((position.character === 0 || linePrefix.trim() === '' || this.couldBeMethodOrKeyword(trimmedPrefix)) &&
@@ -230,6 +248,13 @@ class HttpCompletionProvider {
         }
         return inSingleQuote || inDoubleQuote;
     }
+    /**
+     * Detect the start of a JSON body line (e.g., "{" or "[") under an API request.
+     */
+    isTypingJsonBodyStart(linePrefix) {
+        const trimmed = linePrefix.trimStart();
+        return trimmed.startsWith('{') || trimmed.startsWith('[');
+    }
     /**
      * Check if user is in a context where bare variable names should be suggested.
      * This includes:
@@ -311,7 +336,7 @@ class HttpCompletionProvider {
     getBareVariableCompletions(document, position, linePrefix) {
         const fullText = document.getText();
         const fileVariables = (0, parser_1.extractVariables)(fullText);
-        const envVariables = (0, environmentProvider_1.getEnvironmentVariables)();
+        const envVariables = (0, environmentProvider_1.getEnvironmentVariables)(document.uri.fsPath);
         // Get sequence-local variables if we're inside a sequence
         const sequences = (0, sequenceRunner_1.extractSequences)(fullText);
         const cursorLine = position.line;
@@ -397,6 +422,11 @@ class HttpCompletionProvider {
     // Only trigger when there's content before the {
     isTypingVariable(linePrefix) {
         const trimmed = linePrefix.trim();
+        // JSON body/object start should not trigger variable completions.
+        // Body IntelliSense handles this context separately.
+        if (trimmed === '{' || trimmed === '[') {
+            return false;
+        }
         // Must have something before the brace (not just starting with {)
         // e.g., "GET {{" or "Authorization: Bearer {{"
         // Check for {{ with content before it
@@ -741,12 +771,23 @@ class HttpCompletionProvider {
      * Load API definitions (header groups and endpoints) from imported .nornapi files.
      */
     getApiDefinitionsFromImports(document) {
+        const apiMetadata = this.getApiImportMetadata(document);
+        return {
+            headerGroups: apiMetadata.headerGroups,
+            endpoints: apiMetadata.endpoints
+        };
+    }
+    /**
+     * Load imported .nornapi files with endpoint/header data and swagger URL metadata.
+     */
+    getApiImportMetadata(document) {
         const fullText = document.getText();
         const imports = (0, parser_1.extractImports)(fullText);
         const headerGroups = [];
         const endpoints = [];
+        const apiFiles = [];
         if (imports.length === 0) {
-            return { headerGroups, endpoints };
+            return { headerGroups, endpoints, apiFiles };
         }
         const documentDir = path.dirname(document.uri.fsPath);
         for (const imp of imports) {
@@ -760,12 +801,486 @@ class HttpCompletionProvider {
                 const apiDef = (0, nornapiParser_1.parseNornApiFile)(importedContent);
                 headerGroups.push(...apiDef.headerGroups);
                 endpoints.push(...apiDef.endpoints);
+                apiFiles.push({
+                    sourcePath: importPath,
+                    headerGroups: apiDef.headerGroups,
+                    endpoints: apiDef.endpoints,
+                    swaggerUrls: this.extractSwaggerUrlsFromNornapi(importedContent)
+                });
             }
             catch {
                 // Ignore import errors
             }
         }
-        return { headerGroups, endpoints };
+        return { headerGroups, endpoints, apiFiles };
+    }
+    extractSwaggerUrlsFromNornapi(content) {
+        const urls = new Set();
+        const lines = content.split('\n');
+        for (const line of lines) {
+            const trimmed = line.trim();
+            if (!trimmed || trimmed.startsWith('#')) {
+                continue;
+            }
+            const quotedMatch = trimmed.match(/^swagger\s+["']([^"']+)["']\s*$/i);
+            if (quotedMatch) {
+                urls.add(quotedMatch[1]);
+                continue;
+            }
+            const unquotedMatch = trimmed.match(/^swagger\s+(https?:\/\/\S+)\s*$/i);
+            if (unquotedMatch) {
+                urls.add(unquotedMatch[1]);
+            }
+        }
+        return Array.from(urls);
+    }
+    getRequestBodyCompletionContext(document, position) {
+        const apiMetadata = this.getApiImportMetadata(document);
+        if (apiMetadata.endpoints.length === 0 || apiMetadata.apiFiles.length === 0) {
+            return undefined;
+        }
+        const endpointSchemaMap = this.getEndpointRequestBodySchemaMap(apiMetadata);
+        if (endpointSchemaMap.size === 0) {
+            return undefined;
+        }
+        const headerGroupNames = new Set(apiMetadata.headerGroups.map(group => group.name));
+        for (let lineNum = position.line; lineNum >= 0 && lineNum >= position.line - 80; lineNum--) {
+            const trimmed = document.lineAt(lineNum).text.trim();
+            if (!trimmed || trimmed.startsWith('#')) {
+                continue;
+            }
+            const requestMatch = trimmed.match(/^(?:var\s+[a-zA-Z_][a-zA-Z0-9_]*\s*=\s*)?(GET|POST|PUT|DELETE|PATCH|HEAD|OPTIONS)\s+([a-zA-Z_][a-zA-Z0-9_]*)(?:\([^)]*\))?(?:\s+.*)?$/i);
+            if (requestMatch) {
+                const method = requestMatch[1].toUpperCase();
+                const endpointName = requestMatch[2];
+                if (!this.isRequestBodyMethod(method)) {
+                    return undefined;
+                }
+                const mapped = endpointSchemaMap.get(endpointName);
+                if (!mapped) {
+                    return undefined;
+                }
+                if (mapped.endpoint.method.toUpperCase() !== method) {
+                    return undefined;
+                }
+                const bodyStartLine = this.findRequestBodyStartLine(document, lineNum, position.line, headerGroupNames);
+                if (bodyStartLine === undefined || position.line < bodyStartLine) {
+                    return undefined;
+                }
+                return {
+                    method,
+                    endpointName,
+                    endpoint: mapped.endpoint,
+                    schema: mapped.schema,
+                    bodyStartLine
+                };
+            }
+            if (lineNum !== position.line && this.isBoundaryCommandLine(trimmed)) {
+                return undefined;
+            }
+        }
+        return undefined;
+    }
+    getEndpointRequestBodySchemaMap(apiMetadata) {
+        const endpointSchemaMap = new Map();
+        for (const apiFile of apiMetadata.apiFiles) {
+            if (apiFile.swaggerUrls.length === 0 || apiFile.endpoints.length === 0) {
+                continue;
+            }
+            const cacheEntries = apiFile.swaggerUrls
+                .map(url => (0, swaggerBodyIntellisenseCache_1.getCachedRequestBodySchemasForUrl)(url))
+                .filter((entry) => !!entry);
+            if (cacheEntries.length === 0) {
+                continue;
+            }
+            for (const endpoint of apiFile.endpoints) {
+                if (!this.isRequestBodyMethod(endpoint.method) || endpointSchemaMap.has(endpoint.name)) {
+                    continue;
+                }
+                const method = endpoint.method.toUpperCase();
+                for (const cacheEntry of cacheEntries) {
+                    const normalizedPath = this.normalizeEndpointPathForSwagger(endpoint.path, cacheEntry.baseUrl);
+                    if (!normalizedPath) {
+                        continue;
+                    }
+                    const matchedSchema = cacheEntry.schemas.find(schema => schema.method.toUpperCase() === method &&
+                        schema.path === normalizedPath);
+                    if (!matchedSchema) {
+                        continue;
+                    }
+                    endpointSchemaMap.set(endpoint.name, {
+                        endpoint,
+                        schema: matchedSchema
+                    });
+                    break;
+                }
+            }
+        }
+        return endpointSchemaMap;
+    }
+    normalizeEndpointPathForSwagger(endpointPath, baseUrl) {
+        const rawPath = endpointPath.trim();
+        if (!rawPath) {
+            return undefined;
+        }
+        const getBasePath = () => {
+            if (!baseUrl) {
+                return '';
+            }
+            try {
+                const parsed = new URL(baseUrl);
+                return parsed.pathname.replace(/\/$/, '');
+            }
+            catch {
+                return '';
+            }
+        };
+        const basePath = getBasePath();
+        const normalizeAndStripBasePath = (candidatePath) => {
+            const withoutQuery = candidatePath.split(/[?#]/)[0];
+            let normalized = withoutQuery.startsWith('/') ? withoutQuery : `/${withoutQuery}`;
+            if (basePath) {
+                if (normalized === basePath) {
+                    return '/';
+                }
+                if (normalized.startsWith(`${basePath}/`)) {
+                    normalized = normalized.slice(basePath.length);
+                }
+            }
+            return normalized || '/';
+        };
+        // Handle variable-prefix paths: {{baseUrl}}/users, {{apiRoot}}/v2/users, etc.
+        const variablePrefixMatch = rawPath.match(/^\{\{[^}]+\}\}(.*)$/);
+        if (variablePrefixMatch) {
+            const suffix = variablePrefixMatch[1] || '';
+            return normalizeAndStripBasePath(suffix || '/');
+        }
+        // Most imported endpoints are generated as full URLs, so strip baseUrl first when possible.
+        if (baseUrl && rawPath.startsWith(baseUrl)) {
+            const stripped = rawPath.slice(baseUrl.length);
+            return normalizeAndStripBasePath(stripped || '/');
+        }
+        if (/^https?:\/\//i.test(rawPath)) {
+            try {
+                const endpointUrl = new URL(rawPath);
+                if (baseUrl) {
+                    try {
+                        const parsedBaseUrl = new URL(baseUrl, endpointUrl.origin);
+                        const basePath = parsedBaseUrl.pathname.replace(/\/$/, '');
+                        // Compare by host to tolerate scheme differences (http vs https).
+                        if (endpointUrl.hostname === parsedBaseUrl.hostname) {
+                            if (basePath && endpointUrl.pathname.startsWith(`${basePath}/`)) {
+                                return endpointUrl.pathname.slice(basePath.length);
+                            }
+                            if (basePath && endpointUrl.pathname === basePath) {
+                                return '/';
+                            }
+                        }
+                    }
+                    catch {
+                        // Ignore malformed base URL values (e.g., templated server URLs)
+                    }
+                }
+                return normalizeAndStripBasePath(endpointUrl.pathname || '/');
+            }
+            catch {
+                return undefined;
+            }
+        }
+        return normalizeAndStripBasePath(rawPath);
+    }
+    findRequestBodyStartLine(document, requestLine, currentLine, headerGroupNames) {
+        for (let lineNum = requestLine + 1; lineNum <= currentLine; lineNum++) {
+            const trimmed = document.lineAt(lineNum).text.trim();
+            if (!trimmed || trimmed.startsWith('#')) {
+                continue;
+            }
+            if (headerGroupNames.has(trimmed)) {
+                continue;
+            }
+            if (this.isInlineHeaderLine(trimmed)) {
+                continue;
+            }
+            return lineNum;
+        }
+        return undefined;
+    }
+    isInlineHeaderLine(trimmedLine) {
+        return /^[A-Za-z][A-Za-z0-9-]*:\s*.+$/.test(trimmedLine);
+    }
+    isBoundaryCommandLine(trimmedLine) {
+        return /^(###|\[|(?:test\s+)?sequence\b|end\s+sequence\b|end\s+if\b|endif\b|var\s+|run\s+|print\s+|assert\s+|if\s+|wait\s+|import\s+|return\s+|swagger\b|(GET|POST|PUT|DELETE|PATCH|HEAD|OPTIONS)\s+)/i.test(trimmedLine);
+    }
+    isRequestBodyMethod(method) {
+        return method === 'POST' || method === 'PUT' || method === 'PATCH';
+    }
+    getRequestBodyTemplateCompletions(context, position, lineText) {
+        const templateValue = this.buildTemplateValueFromSchema(context.schema.schema);
+        const rawTemplate = JSON.stringify(templateValue, null, 4);
+        if (!rawTemplate) {
+            return [];
+        }
+        const indentation = lineText.match(/^\s*/)[0];
+        const indentedTemplate = rawTemplate
+            .split('\n')
+            .map(line => indentation + line)
+            .join('\n');
+        const replaceRange = new vscode.Range(new vscode.Position(position.line, 0), new vscode.Position(position.line, lineText.length));
+        const item = new vscode.CompletionItem('Insert request body template', vscode.CompletionItemKind.Snippet);
+        item.insertText = indentedTemplate;
+        item.range = replaceRange;
+        const triggerChar = lineText.trimStart().startsWith('[') ? '[' : '{';
+        item.filterText = triggerChar;
+        item.preselect = true;
+        item.detail = `${context.method} ${context.endpointName}`;
+        item.documentation = new vscode.MarkdownString(`Insert a request body skeleton for \`${context.endpointName}\` from cached Swagger schema.\n\n` +
+            'Template includes required fields only.');
+        item.sortText = '0_request_body_template';
+        return [item];
+    }
+    buildTemplateValueFromSchema(schema) {
+        const normalizedSchema = this.normalizeSchemaForCompletions(schema);
+        const value = this.buildDefaultSchemaValue(normalizedSchema, true);
+        return value === undefined ? {} : value;
+    }
+    buildDefaultSchemaValue(schema, requiredOnly) {
+        const normalizedSchema = this.normalizeSchemaForCompletions(schema);
+        if (!normalizedSchema || typeof normalizedSchema !== 'object') {
+            return null;
+        }
+        if (normalizedSchema.default !== undefined) {
+            return normalizedSchema.default;
+        }
+        if (Array.isArray(normalizedSchema.enum) && normalizedSchema.enum.length > 0) {
+            return normalizedSchema.enum[0];
+        }
+        if (normalizedSchema.type === 'object' || normalizedSchema.properties) {
+            const properties = normalizedSchema.properties;
+            if (!properties || Object.keys(properties).length === 0) {
+                return {};
+            }
+            const required = Array.isArray(normalizedSchema.required)
+                ? normalizedSchema.required.filter((name) => typeof name === 'string')
+                : [];
+            const keys = requiredOnly
+                ? (required.length > 0 ? required : Object.keys(properties))
+                : Object.keys(properties);
+            const result = {};
+            for (const key of keys) {
+                result[key] = this.buildDefaultSchemaValue(properties[key], requiredOnly);
+            }
+            return result;
+        }
+        if (normalizedSchema.type === 'array' || normalizedSchema.items) {
+            return [];
+        }
+        switch (normalizedSchema.type) {
+            case 'number':
+            case 'integer':
+                return 0;
+            case 'boolean':
+                return false;
+            case 'string':
+                return '';
+            case 'null':
+                return null;
+            default:
+                return null;
+        }
+    }
+    getInlineRequestBodyKeyCompletions(context, document, position, linePrefix) {
+        if (!this.isTypingJsonObjectKey(linePrefix)) {
+            return [];
+        }
+        const bodyLinesBeforeCursor = [];
+        for (let lineNum = context.bodyStartLine; lineNum < position.line; lineNum++) {
+            bodyLinesBeforeCursor.push(document.lineAt(lineNum).text);
+        }
+        const jsonContext = this.parseJsonObjectContext(bodyLinesBeforeCursor);
+        const schemaNode = this.getSchemaNodeForPath(context.schema.schema, jsonContext.path);
+        const normalizedSchema = this.normalizeSchemaForCompletions(schemaNode);
+        const properties = normalizedSchema?.properties;
+        if (!properties || Object.keys(properties).length === 0) {
+            return [];
+        }
+        const required = new Set(Array.isArray(normalizedSchema.required)
+            ? normalizedSchema.required.filter((name) => typeof name === 'string')
+            : []);
+        const replaceTokenMatch = linePrefix.match(/"?[a-zA-Z0-9_-]*$/);
+        const replaceToken = replaceTokenMatch ? replaceTokenMatch[0] : '';
+        const partialMatch = linePrefix.match(/"?([a-zA-Z_][a-zA-Z0-9_-]*)?$/);
+        const partial = partialMatch?.[1]?.toLowerCase() || '';
+        const replaceStart = Math.max(0, position.character - replaceToken.length);
+        const replaceRange = new vscode.Range(new vscode.Position(position.line, replaceStart), position);
+        const items = [];
+        for (const [propertyName, propertySchema] of Object.entries(properties)) {
+            if (jsonContext.existingKeys.has(propertyName)) {
+                continue;
+            }
+            if (partial && !propertyName.toLowerCase().startsWith(partial)) {
+                continue;
+            }
+            const item = new vscode.CompletionItem(propertyName, vscode.CompletionItemKind.Property);
+            item.range = replaceRange;
+            item.insertText = `"${propertyName}": `;
+            item.detail = required.has(propertyName)
+                ? `${this.getSchemaTypeDescription(propertySchema)} (required)`
+                : this.getSchemaTypeDescription(propertySchema);
+            item.documentation = new vscode.MarkdownString(`Schema property for \`${context.endpointName}\` request body.`);
+            item.sortText = required.has(propertyName)
+                ? `0_${propertyName}`
+                : `1_${propertyName}`;
+            items.push(item);
+        }
+        return items;
+    }
+    isTypingJsonObjectKey(linePrefix) {
+        const trimmed = linePrefix.trim();
+        if (trimmed.startsWith('{') || trimmed.startsWith('[') || trimmed.startsWith('}') || trimmed.startsWith(']')) {
+            return false;
+        }
+        if (trimmed.includes(':') || trimmed.includes(',')) {
+            return false;
+        }
+        if (trimmed === '' || trimmed === '"') {
+            return true;
+        }
+        return /^"?[a-zA-Z_][a-zA-Z0-9_-]*$/.test(trimmed);
+    }
+    parseJsonObjectContext(lines) {
+        const pathStack = [];
+        const keysByPath = new Map();
+        const getPathKey = () => pathStack.join('.');
+        const ensureKeySet = (pathKey) => {
+            if (!keysByPath.has(pathKey)) {
+                keysByPath.set(pathKey, new Set());
+            }
+            return keysByPath.get(pathKey);
+        };
+        for (const line of lines) {
+            const trimmed = line.trim();
+            if (!trimmed || trimmed.startsWith('#')) {
+                continue;
+            }
+            const closingMatch = trimmed.match(/^[}\]]+/);
+            if (closingMatch) {
+                for (const _ of closingMatch[0]) {
+                    if (pathStack.length > 0) {
+                        pathStack.pop();
+                    }
+                }
+            }
+            const currentPath = getPathKey();
+            const addExistingKey = (key) => {
+                ensureKeySet(currentPath).add(key);
+            };
+            const objectStartMatch = trimmed.match(/^"([^"]+)"\s*:\s*\{\s*,?\s*$/);
+            if (objectStartMatch) {
+                addExistingKey(objectStartMatch[1]);
+                pathStack.push(objectStartMatch[1]);
+                continue;
+            }
+            const arrayStartMatch = trimmed.match(/^"([^"]+)"\s*:\s*\[\s*,?\s*$/);
+            if (arrayStartMatch) {
+                addExistingKey(arrayStartMatch[1]);
+                pathStack.push(arrayStartMatch[1]);
+                continue;
+            }
+            const propertyMatch = trimmed.match(/^"([^"]+)"\s*:/);
+            if (propertyMatch) {
+                addExistingKey(propertyMatch[1]);
+            }
+        }
+        const finalPath = getPathKey();
+        return {
+            path: [...pathStack],
+            existingKeys: new Set(keysByPath.get(finalPath) || [])
+        };
+    }
+    getSchemaNodeForPath(schema, pathSegments) {
+        let currentSchema = this.normalizeSchemaForCompletions(schema);
+        for (const segment of pathSegments) {
+            currentSchema = this.normalizeSchemaForCompletions(currentSchema);
+            if (!currentSchema || typeof currentSchema !== 'object') {
+                return undefined;
+            }
+            const properties = currentSchema.properties;
+            if (!properties || !(segment in properties)) {
+                return undefined;
+            }
+            const propertySchema = this.normalizeSchemaForCompletions(properties[segment]);
+            if (propertySchema?.type === 'array' && propertySchema.items) {
+                currentSchema = this.normalizeSchemaForCompletions(propertySchema.items);
+            }
+            else {
+                currentSchema = propertySchema;
+            }
+        }
+        return this.normalizeSchemaForCompletions(currentSchema);
+    }
+    normalizeSchemaForCompletions(schema) {
+        if (!schema || typeof schema !== 'object') {
+            return schema;
+        }
+        if (Array.isArray(schema.allOf) && schema.allOf.length > 0) {
+            const merged = { ...schema };
+            delete merged.allOf;
+            for (const part of schema.allOf) {
+                const normalizedPart = this.normalizeSchemaForCompletions(part);
+                if (!normalizedPart || typeof normalizedPart !== 'object') {
+                    continue;
+                }
+                if (!merged.type && normalizedPart.type) {
+                    merged.type = normalizedPart.type;
+                }
+                if (normalizedPart.properties && typeof normalizedPart.properties === 'object') {
+                    merged.properties = {
+                        ...(merged.properties || {}),
+                        ...normalizedPart.properties
+                    };
+                }
+                if (normalizedPart.items && !merged.items) {
+                    merged.items = normalizedPart.items;
+                }
+                if (Array.isArray(normalizedPart.required)) {
+                    const existing = Array.isArray(merged.required) ? merged.required : [];
+                    merged.required = Array.from(new Set([...existing, ...normalizedPart.required]));
+                }
+            }
+            return merged;
+        }
+        if (Array.isArray(schema.oneOf) && schema.oneOf.length > 0) {
+            return this.normalizeSchemaForCompletions(schema.oneOf[0]);
+        }
+        if (Array.isArray(schema.anyOf) && schema.anyOf.length > 0) {
+            return this.normalizeSchemaForCompletions(schema.anyOf[0]);
+        }
+        return schema;
+    }
+    getSchemaTypeDescription(schema) {
+        const normalizedSchema = this.normalizeSchemaForCompletions(schema);
+        if (!normalizedSchema || typeof normalizedSchema !== 'object') {
+            return 'value';
+        }
+        if (Array.isArray(normalizedSchema.enum) && normalizedSchema.enum.length > 0) {
+            const enumPreview = normalizedSchema.enum
+                .slice(0, 3)
+                .map((value) => JSON.stringify(value))
+                .join(', ');
+            return normalizedSchema.enum.length > 3
+                ? `enum (${enumPreview}, ...)`
+                : `enum (${enumPreview})`;
+        }
+        if (typeof normalizedSchema.type === 'string') {
+            return normalizedSchema.type;
+        }
+        if (normalizedSchema.properties) {
+            return 'object';
+        }
+        if (normalizedSchema.items) {
+            return 'array';
+        }
+        return 'value';
     }
     /**
      * Check if user is typing after an HTTP method (e.g., "GET " or "POST " or "var x = GET ")
@@ -956,16 +1471,15 @@ class HttpCompletionProvider {
         return items;
     }
     /**
-     * Check if we're on a line after an API request (METHOD EndpointName).
-     * This is used to provide header completions for API endpoint requests.
-     * Allows inline headers and header groups on lines following an API endpoint.
+     * Check if we're on a line after an HTTP request.
+     * Supports:
+     * - METHOD EndpointName / METHOD URL
+     * - var x = METHOD EndpointName / URL
+     * Allows inline headers and header groups on following lines.
      */
     isAfterApiRequest(document, position) {
         const apiDefs = this.getApiDefinitionsFromImports(document);
-        if (apiDefs.endpoints.length === 0) {
-            return false;
-        }
-        // Look at previous lines to see if we're after an API request
+        // Look at previous lines to see if we're after a request block start.
         for (let lineNum = position.line - 1; lineNum >= 0 && lineNum >= position.line - 10; lineNum--) {
             const prevLine = document.lineAt(lineNum).text.trim();
             // Skip empty lines
@@ -973,6 +1487,10 @@ class HttpCompletionProvider {
                 // Empty line means we're past the request block
                 return false;
             }
+            // Skip comment lines
+            if (prevLine.startsWith('#')) {
+                continue;
+            }
             // Skip header group names on their own line
             if (apiDefs.headerGroups.some(hg => hg.name === prevLine)) {
                 continue;
@@ -981,13 +1499,13 @@ class HttpCompletionProvider {
             if (/^[A-Za-z][A-Za-z0-9-]*:\s*.+$/.test(prevLine)) {
                 continue;
             }
-            // Check if this line is an API request (METHOD EndpointName)
-            const match = prevLine.match(/^(GET|POST|PUT|DELETE|PATCH|HEAD|OPTIONS)\s+([a-zA-Z_][a-zA-Z0-9_]*)(?:\([^)]*\))?/i);
-            if (match) {
-                const endpointName = match[2];
-                if (apiDefs.endpoints.some(ep => ep.name === endpointName)) {
-                    return true;
-                }
+            // Request start: METHOD ...
+            if (/^(GET|POST|PUT|DELETE|PATCH|HEAD|OPTIONS)\s+.+$/i.test(prevLine)) {
+                return true;
+            }
+            // Request start: var x = METHOD ...
+            if (/^var\s+[a-zA-Z_][a-zA-Z0-9_]*\s*=\s*(GET|POST|PUT|DELETE|PATCH|HEAD|OPTIONS)\s+.+$/i.test(prevLine)) {
+                return true;
             }
             // If we hit another kind of line that's not recognized, stop
             break;
@@ -1062,7 +1580,7 @@ class HttpCompletionProvider {
     getVariableCompletions(document, linePrefix, lineSuffix) {
         const fullText = document.getText();
         const fileVariables = (0, parser_1.extractVariables)(fullText);
-        const envVariables = (0, environmentProvider_1.getEnvironmentVariables)();
+        const envVariables = (0, environmentProvider_1.getEnvironmentVariables)(document.uri.fsPath);
         const activeEnv = (0, environmentProvider_1.getActiveEnvironment)();
         // Merge: env variables first, then file variables (file takes precedence for values)
         const allVariables = {};
@@ -1396,7 +1914,7 @@ class HttpCompletionProvider {
     getVariablePathCompletions(document, prefix) {
         const fullText = document.getText();
         const fileVariables = (0, parser_1.extractVariables)(fullText);
-        const envVariables = (0, environmentProvider_1.getEnvironmentVariables)();
+        const envVariables = (0, environmentProvider_1.getEnvironmentVariables)(document.uri.fsPath);
         const allVariables = { ...envVariables, ...fileVariables };
         const items = [];
         const lowerPrefix = prefix.toLowerCase();