norn-cli 1.3.17 → 1.3.19

package/AGENTS.md

@@ -0,0 +1,72 @@
+# Norn Extension - Copilot Instructions
+
+These instructions apply to all conversations about the Norn VS Code extension.
+
+## CLI Support is Mandatory
+
+Every feature implementation must work in both:
+1. **VS Code Extension** - Interactive UI with response panel
+2. **CLI** (`src/cli.ts`) - Command-line execution
+
+Before considering any feature complete, verify it works in the CLI. The CLI shares code with the extension (`parser.ts`, `sequenceRunner.ts`, `assertionRunner.ts`, `httpClient.ts`).
+
+### CRITICAL: Running the Local CLI
+
+**NEVER use `npx norn`** - this runs the globally installed npm package, NOT your local changes!
+
+**ALWAYS use the local compiled CLI:**
+```bash
+# Correct - runs your local development version
+node ./dist/cli.js run tests/file.norn --env prelive
+
+# WRONG - runs the published npm package, ignores your changes
+npx norn run tests/file.norn
+```
+
+Before testing CLI changes:
+1. Run `npm run compile` to build the latest code
+2. Use `node ./dist/cli.js` to execute
+
+## Skills Maintenance
+
+When implementing features, check the `.github/skills/` directory for relevant skills:
+
+- **If a skill is incorrect or outdated:** Update it with the correct information
+- **If a skill is missing:** Create a new one following the Agent Skills format
+
+Skills should capture lessons learned and patterns discovered during implementation to help future development.
+
+## Code Style
+
+- TypeScript with strict typing
+- Simple IntelliSense completions (no complex snippets)
+- Keep parsing logic in dedicated functions
+- Test both extension and CLI after changes
+
+## Test Verification
+
+**MANDATORY:** When the user asks to publish, prepare a release, bump version, or create a patch:
+1. **FIRST** invoke the Test Verification subagent using `runSubagent`
+2. Wait for it to complete and report results
+3. Only proceed if all tests pass
+
+The Test Verification agent runs:
+- `npm run compile` (must have 0 errors)
+- `node ./dist/cli.js ./tests/Regression/ -e prelive` (all tests must pass)
+
+**Trigger words:** publish, release, version, patch, bump, deploy
+
+## Key Files
+
+| Purpose | File |
+|---------|------|
+| Syntax highlighting | `syntaxes/norn.tmLanguage.json` |
+| IntelliSense | `src/completionProvider.ts` |
+| Sequence execution | `src/sequenceRunner.ts` |
+| Assertions | `src/assertionRunner.ts` |
+| HTTP requests | `src/httpClient.ts` |
+| CLI | `src/cli.ts` |
+| Parser | `src/parser.ts` |
+| Response panel | `src/responsePanel.ts` |
+| Diagnostics | `src/diagnosticProvider.ts` |
+| Test Explorer | `src/testProvider.ts` |

package/CHANGELOG.md

@@ -2,6 +2,44 @@
 
 All notable changes to the "Norn" extension will be documented in this file.
 
+## [1.3.19] - 2026-02-15
+
+### Added
+- **Swagger Request Body IntelliSense (Endpoint Calls)**:
+  - Added request body template insertion for `POST`/`PUT`/`PATCH` endpoint calls backed by Swagger metadata.
+  - Added inline JSON key suggestions inside request bodies using cached Swagger request schemas.
+  - Added persistent request-schema cache in `.norn-cache/swagger-body-intellisense.json`.
+
+### Improved
+- **Swagger Schema Cache Availability**:
+  - Extension now warms request-body schema cache from `.nornapi` `swagger` URLs on startup and on `.nornapi` save.
+
+### Fixed
+- **Request Body Completions**:
+  - Fixed endpoint-to-swagger path mapping when endpoint URLs use variable prefixes like `{{baseUrl}}/...`.
+  - Fixed body-start completion filtering so template suggestions appear reliably when typing `{` / `[`.
+  - Fixed template insertion indentation and fallback behavior when schema has no required fields.
+
+## [1.3.18] - 2026-02-15
+
+### Improved
+- **Environment Resolution (Extension + CLI)**: `.nornenv` resolution is now file-aware and uses the closest ancestor file.
+  - VS Code execution paths now resolve env variables from the current document path.
+  - CLI directory runs now resolve environments per test file path (including nested folders).
+  - CodeLens and environment status now reflect the active editor/file context.
+
+### Fixed
+- **IntelliSense in Request Bodies**:
+  - Header completions are suppressed when starting JSON body lines (`{` or `[`).
+  - Header suggestions remain available for non-body lines, including raw URL requests (e.g., `POST "https://..."`).
+- **Syntax Highlighting**:
+  - Fixed header coloring after endpoint calls where header-group token matching could break on `Content-Type`.
+  - Improved assert string highlighting with variable interpolation inside quoted strings.
+
+### Added
+- **Regression Coverage**:
+  - Added env-resolution regression tests for parent vs nested `.nornenv` precedence.
+
 ## [1.3.17] - 2026-02-14
 
 ### Fixed
@@ -856,4 +894,4 @@ end sequence
 - **IntelliSense**: Autocomplete for methods, headers, variables, and keywords
 - **Diagnostics**: Error highlighting for undefined variables
 - **CLI Tool**: Run requests from terminal with JSON output for CI/CD pipelines
-- **Response Panel**: Webview with formatted JSON and execution results
+- **Response Panel**: Webview with formatted JSON and execution results

package/README.md

@@ -31,7 +31,7 @@ A powerful REST client extension for VS Code with sequences, assertions, environ
 - **Response Comparison**: Compare any two API responses side-by-side with VS Code's diff view
 - **Clickable JSON**: Click any JSON value in the response panel to auto-generate assertions
 - **Syntax Highlighting**: Full syntax highlighting for requests, headers, JSON bodies
-- **IntelliSense**: Autocomplete for HTTP methods, headers, variables, and keywords
+- **IntelliSense**: Autocomplete for HTTP methods, headers, variables, keywords, and Swagger-based request body keys/templates for endpoint POST/PUT/PATCH calls
 - **Diagnostics**: Error highlighting for undefined variables
 - **CLI**: Run tests from terminal with JUnit/HTML reports for CI/CD automation
 
@@ -105,6 +105,8 @@ Content-Type: application/json
 }
 ```
 
+If the request uses an imported endpoint (`POST/PUT/PATCH EndpointName`) backed by a cached Swagger spec, typing `{` on the body line offers **Insert request body template** (required fields only). As you type JSON keys, IntelliSense suggests schema properties for that object.
+
 ### Sequences (Chained Requests)
 
 Chain multiple requests and capture response data:
@@ -340,7 +342,7 @@ end sequence
 - Circular imports are detected and reported as errors
 - Only named requests `[Name]` and sequences are imported
 - Variables are resolved at import time (baked in), not exported
-- `.nornenv` environment variables are shared across all files
+- `.nornenv` resolution is file-aware: Norn walks up from the running file and uses the closest `.nornenv`
 
 ### API Definition Files (.nornapi)
 
@@ -506,7 +508,8 @@ end sequence
 
 ### Environments
 
-Create a `.nornenv` file in your workspace root to manage environment-specific variables:
+Create a `.nornenv` file to manage environment-specific variables.  
+Norn resolves the closest `.nornenv` by walking up from the file being run (or edited):
 
 ```bash
 # .nornenv file
@@ -1017,6 +1020,7 @@ end sequence
 | `var name = value` | Common variable (all environments) |
 | `[env:name]` | Start environment section |
 | `# comment` | Comment line |
+| resolution | Closest ancestor `.nornenv` from the current `.norn`/`.nornapi` file |
 
 ### API Definitions (.nornapi)
 

package/dist/cli.js

@@ -10386,7 +10386,7 @@ var require_ms = __commonJS({
       options = options || {};
       var type = typeof val;
       if (type === "string" && val.length > 0) {
-        return parse3(val);
+        return parse2(val);
       } else if (type === "number" && isFinite(val)) {
         return options.long ? fmtLong(val) : fmtShort(val);
       }
@@ -10394,7 +10394,7 @@ var require_ms = __commonJS({
         "val is not a non-empty string or a valid number. val=" + JSON.stringify(val)
       );
     };
-    function parse3(str) {
+    function parse2(str) {
       str = String(str);
       if (str.length > 100) {
         return;
@@ -12106,7 +12106,7 @@ var require_cjs = __commonJS({
       out.publicSuffix = (_a = hostnameParts[hostnameParts.length - 1]) !== null && _a !== void 0 ? _a : null;
     }
     var RESULT = getEmptyResult();
-    function parse3(url2, options = {}) {
+    function parse2(url2, options = {}) {
       return parseImpl(url2, 5, suffixLookup, options, getEmptyResult());
     }
     function getHostname(url2, options = {}) {
@@ -12134,7 +12134,7 @@ var require_cjs = __commonJS({
     exports2.getHostname = getHostname;
     exports2.getPublicSuffix = getPublicSuffix2;
     exports2.getSubdomain = getSubdomain;
-    exports2.parse = parse3;
+    exports2.parse = parse2;
   }
 });
 
@@ -15684,24 +15684,24 @@ var require_fast_uri = __commonJS({
     function normalize(uri, options) {
       if (typeof uri === "string") {
         uri = /** @type {T} */
-        serialize(parse3(uri, options), options);
+        serialize(parse2(uri, options), options);
       } else if (typeof uri === "object") {
         uri = /** @type {T} */
-        parse3(serialize(uri, options), options);
+        parse2(serialize(uri, options), options);
       }
       return uri;
     }
     function resolve5(baseURI, relativeURI, options) {
       const schemelessOptions = options ? Object.assign({ scheme: "null" }, options) : { scheme: "null" };
-      const resolved = resolveComponent(parse3(baseURI, schemelessOptions), parse3(relativeURI, schemelessOptions), schemelessOptions, true);
+      const resolved = resolveComponent(parse2(baseURI, schemelessOptions), parse2(relativeURI, schemelessOptions), schemelessOptions, true);
       schemelessOptions.skipEscape = true;
       return serialize(resolved, schemelessOptions);
     }
     function resolveComponent(base, relative2, options, skipNormalization) {
       const target = {};
       if (!skipNormalization) {
-        base = parse3(serialize(base, options), options);
-        relative2 = parse3(serialize(relative2, options), options);
+        base = parse2(serialize(base, options), options);
+        relative2 = parse2(serialize(relative2, options), options);
       }
       options = options || {};
       if (!options.tolerant && relative2.scheme) {
@@ -15753,13 +15753,13 @@ var require_fast_uri = __commonJS({
     function equal(uriA, uriB, options) {
       if (typeof uriA === "string") {
         uriA = unescape(uriA);
-        uriA = serialize(normalizeComponentEncoding(parse3(uriA, options), true), { ...options, skipEscape: true });
+        uriA = serialize(normalizeComponentEncoding(parse2(uriA, options), true), { ...options, skipEscape: true });
       } else if (typeof uriA === "object") {
         uriA = serialize(normalizeComponentEncoding(uriA, true), { ...options, skipEscape: true });
       }
       if (typeof uriB === "string") {
         uriB = unescape(uriB);
-        uriB = serialize(normalizeComponentEncoding(parse3(uriB, options), true), { ...options, skipEscape: true });
+        uriB = serialize(normalizeComponentEncoding(parse2(uriB, options), true), { ...options, skipEscape: true });
       } else if (typeof uriB === "object") {
         uriB = serialize(normalizeComponentEncoding(uriB, true), { ...options, skipEscape: true });
       }
@@ -15828,7 +15828,7 @@ var require_fast_uri = __commonJS({
       return uriTokens.join("");
     }
     var URI_PARSE = /^(?:([^#/:?]+):)?(?:\/\/((?:([^#/?@]*)@)?(\[[^#/?\]]+\]|[^#/:?]*)(?::(\d*))?))?([^#?]*)(?:\?([^#]*))?(?:#((?:.|[\n\r])*))?/u;
-    function parse3(uri, opts) {
+    function parse2(uri, opts) {
       const options = Object.assign({}, opts);
       const parsed = {
         scheme: void 0,
@@ -15922,7 +15922,7 @@ var require_fast_uri = __commonJS({
       resolveComponent,
       equal,
       serialize,
-      parse: parse3
+      parse: parse2
     };
     module2.exports = fastUri;
     module2.exports.default = fastUri;
@@ -30269,15 +30269,27 @@ function generateHtmlReportFromResponse(response, testName, options) {
 
 // src/cli.ts
 var ENV_FILENAME = ".nornenv";
+function getEnvSearchStartDirectory(targetPath) {
+  const resolvedPath = path4.resolve(targetPath);
+  try {
+    const stats = fs5.statSync(resolvedPath);
+    return stats.isDirectory() ? resolvedPath : path4.dirname(resolvedPath);
+  } catch {
+    return path4.dirname(resolvedPath);
+  }
+}
 function findEnvFileFromPath(filePath) {
-  let dir = path4.dirname(filePath);
-  const root = path4.parse(dir).root;
-  while (dir !== root) {
+  let dir = getEnvSearchStartDirectory(filePath);
+  while (true) {
     const envPath = path4.join(dir, ENV_FILENAME);
     if (fs5.existsSync(envPath)) {
       return envPath;
     }
-    dir = path4.dirname(dir);
+    const parentDir = path4.dirname(dir);
+    if (parentDir === dir) {
+      break;
+    }
+    dir = parentDir;
   }
   return void 0;
 }
@@ -30333,6 +30345,57 @@ function parseEnvFile(content) {
   }
   return config;
 }
+function resolveEnvironmentForPath(targetPath, selectedEnv) {
+  const envFilePath = findEnvFileFromPath(targetPath);
+  if (!envFilePath) {
+    return {
+      variables: {},
+      secretNames: /* @__PURE__ */ new Set(),
+      secretValues: /* @__PURE__ */ new Map(),
+      availableEnvironments: []
+    };
+  }
+  const envContent = fs5.readFileSync(envFilePath, "utf-8");
+  const envConfig = parseEnvFile(envContent);
+  const variables = { ...envConfig.common };
+  const secretNames = new Set(envConfig.secretNames);
+  const secretValues = new Map(envConfig.secretValues);
+  const availableEnvironments = envConfig.environments.map((e) => e.name);
+  if (selectedEnv) {
+    const targetEnv = envConfig.environments.find((e) => e.name === selectedEnv);
+    if (!targetEnv) {
+      return {
+        envFilePath,
+        variables,
+        secretNames,
+        secretValues,
+        availableEnvironments,
+        envNotFound: selectedEnv
+      };
+    }
+    Object.assign(variables, targetEnv.variables);
+    for (const [name, value] of Object.entries(targetEnv.variables)) {
+      if (secretNames.has(name)) {
+        secretValues.set(name, value);
+      }
+    }
+  }
+  return {
+    envFilePath,
+    variables,
+    secretNames,
+    secretValues,
+    availableEnvironments
+  };
+}
+function mergeSecrets(targetNames, targetValues, sourceNames, sourceValues) {
+  for (const name of sourceNames) {
+    targetNames.add(name);
+  }
+  for (const [name, value] of sourceValues) {
+    targetValues.set(name, value);
+  }
+}
 function generateTimestamp() {
   const now = /* @__PURE__ */ new Date();
   const year = now.getFullYear();
@@ -30739,38 +30802,8 @@ async function main() {
   const allErrors = [];
   let overallSuccess = true;
   const startTime = Date.now();
-  const envFilePath = findEnvFileFromPath(inputPath);
-  let envVariables = {};
-  let redaction = createRedactionOptions(/* @__PURE__ */ new Set(), /* @__PURE__ */ new Map(), !options.noRedact);
-  if (envFilePath) {
-    const envContent = fs5.readFileSync(envFilePath, "utf-8");
-    const envConfig = parseEnvFile(envContent);
-    envVariables = { ...envConfig.common };
-    redaction = createRedactionOptions(
-      envConfig.secretNames,
-      envConfig.secretValues,
-      !options.noRedact
-    );
-    if (options.env) {
-      const targetEnv = envConfig.environments.find((e) => e.name === options.env);
-      if (!targetEnv) {
-        console.error(`Error: Environment '${options.env}' not found in .nornenv`);
-        console.error(`Available environments: ${envConfig.environments.map((e) => e.name).join(", ") || "none"}`);
-        process.exit(1);
-      }
-      Object.assign(envVariables, targetEnv.variables);
-      for (const [name, value] of Object.entries(targetEnv.variables)) {
-        if (envConfig.secretNames.has(name)) {
-          redaction.secretValues.set(name, value);
-        }
-      }
-      if (options.verbose) {
-        console.log(colors.info(`Using environment: ${options.env}`));
-      }
-    }
-  } else if (options.env) {
-    console.error(colors.warning(`Warning: --env specified but no .nornenv file found`));
-  }
+  const combinedSecretNames = /* @__PURE__ */ new Set();
+  const combinedSecretValues = /* @__PURE__ */ new Map();
   let tagFilterOptions = void 0;
   if (options.tagFilters.length > 0) {
     tagFilterOptions = {
@@ -30789,9 +30822,22 @@ async function main() {
   }
   if (options.sequence || options.request) {
     const filePath = filesToRun[0];
+    const resolvedEnv = resolveEnvironmentForPath(filePath, options.env);
+    if (resolvedEnv.envNotFound) {
+      console.error(`Error: Environment '${resolvedEnv.envNotFound}' not found in .nornenv`);
+      console.error(`Available environments: ${resolvedEnv.availableEnvironments.join(", ") || "none"}`);
+      process.exit(1);
+    }
+    if (!resolvedEnv.envFilePath && options.env) {
+      console.error(colors.warning(`Warning: --env specified but no .nornenv file found`));
+    } else if (resolvedEnv.envFilePath && options.env && options.verbose) {
+      console.log(colors.info(`Using environment: ${options.env}`));
+    }
+    mergeSecrets(combinedSecretNames, combinedSecretValues, resolvedEnv.secretNames, resolvedEnv.secretValues);
+    const redaction2 = createRedactionOptions(combinedSecretNames, combinedSecretValues, !options.noRedact);
     const fileContent = fs5.readFileSync(filePath, "utf-8");
     const fileVariables = extractFileLevelVariables(fileContent);
-    const variables = { ...envVariables, ...fileVariables };
+    const variables = { ...resolvedEnv.variables, ...fileVariables };
     const cookieJar = createCookieJar();
     const workingDir = path4.dirname(filePath);
     const importResult = await resolveImports(
@@ -30835,7 +30881,7 @@ ${fileContent}` : fileContent;
         console.log(JSON.stringify({ success: response.status >= 200 && response.status < 400, results: [response] }, null, 2));
       } else {
         const isSuccess = response.status >= 200 && response.status < 300;
-        const lines = formatResponse(response, { colors, verbose: options.verbose, showDetails: !isSuccess || options.verbose, redaction });
+        const lines = formatResponse(response, { colors, verbose: options.verbose, showDetails: !isSuccess || options.verbose, redaction: redaction2 });
         for (const line2 of lines) {
           console.log(line2);
         }
@@ -30878,7 +30924,7 @@ ${fileContent}` : fileContent;
       if (options.output === "json") {
         console.log(JSON.stringify({ success: seqResult.success, results: [seqResult] }, null, 2));
       } else {
-        const lines = formatSequenceResult(seqResult, { colors, verbose: options.verbose, redaction });
+        const lines = formatSequenceResult(seqResult, { colors, verbose: options.verbose, redaction: redaction2 });
         for (const line2 of lines) {
           console.log(line2);
         }
@@ -30912,9 +30958,21 @@ ${fileContent}` : fileContent;
     console.log("");
   }
   for (const filePath of filesToRun) {
+    const resolvedEnv = resolveEnvironmentForPath(filePath, options.env);
+    if (resolvedEnv.envNotFound) {
+      console.error(`Error: Environment '${resolvedEnv.envNotFound}' not found in .nornenv`);
+      console.error(`Available environments: ${resolvedEnv.availableEnvironments.join(", ") || "none"}`);
+      process.exit(1);
+    }
+    if (!resolvedEnv.envFilePath && options.env) {
+      const relPath = isDirectory ? path4.relative(inputPath, filePath) : path4.basename(filePath);
+      console.error(colors.warning(`Warning: --env specified but no .nornenv file found for ${relPath}`));
+    }
+    mergeSecrets(combinedSecretNames, combinedSecretValues, resolvedEnv.secretNames, resolvedEnv.secretValues);
+    const redaction2 = createRedactionOptions(combinedSecretNames, combinedSecretValues, !options.noRedact);
     const fileContent = fs5.readFileSync(filePath, "utf-8");
     const fileVariables = extractFileLevelVariables(fileContent);
-    const variables = { ...envVariables, ...fileVariables };
+    const variables = { ...resolvedEnv.variables, ...fileVariables };
     const cookieJar = createCookieJar();
     const workingDir = path4.dirname(filePath);
     const importResult = await resolveImports(
@@ -30964,7 +31022,7 @@ ${fileContent}` : fileContent;
     }
     if (options.output !== "json") {
       for (const seqResult of seqResults) {
-        const lines = formatSequenceResult(seqResult, { colors, verbose: options.verbose, redaction });
+        const lines = formatSequenceResult(seqResult, { colors, verbose: options.verbose, redaction: redaction2 });
         for (const line2 of lines) {
           console.log(line2);
         }
@@ -30972,6 +31030,7 @@ ${fileContent}` : fileContent;
     }
   }
   const totalDuration = Date.now() - startTime;
+  const redaction = createRedactionOptions(combinedSecretNames, combinedSecretValues, !options.noRedact);
   const result = {
     success: overallSuccess,
     type: "all-sequences",