norn-cli 1.3.1 → 1.3.2

package/CHANGELOG.md

@@ -2,6 +2,21 @@
 
 All notable changes to the "Norn" extension will be documented in this file.
 
+## [1.3.2] - 2026-02-08
+
+### Improved
+- **Contract Report View**: Enhanced property highlighting in the annotated JSON view
+  - Color-coded property highlights (green=valid, yellow=warning, red=error)
+  - Highlights wrap only the property content, not the entire line
+  - Selection-style highlighting similar to assert hover
+  - Improved indentation and spacing
+
+### Fixed
+- **Syntax Highlighting**: Fixed JSON body coloring after nested objects
+  - Properties following `{ }` objects now correctly colored
+- **matchesSchema Keyword**: Fixed partial coloring issue
+  - Entire keyword now highlights as operator (was matching "matches" first)
+
 ## [1.3.1] - 2026-02-08
 
 - **Clickable JSON Properties**: Click any JSON value in the response panel to generate an assertion

package/README.md

@@ -28,6 +28,8 @@ A powerful REST client extension for VS Code with sequences, assertions, environ
 - **Script Execution**: Run bash, PowerShell, or JavaScript scripts within sequences
 - **Print Statements**: Debug and log messages during sequence execution
 - **Cookie Support**: Automatic cookie jar with persistence across requests
+- **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
 - **Diagnostics**: Error highlighting for undefined variables
@@ -742,6 +744,37 @@ end sequence
 
 Use `print "Title" | "Body content"` for expandable messages in the result view.
 
+### Response Panel Tools
+
+The response panel provides interactive tools that accelerate test development:
+
+#### Response Comparison
+
+Compare any two API responses side-by-side using VS Code's built-in diff view:
+
+1. Click **⇄ Compare** on the first response body
+2. Click **⇄ Compare** on the second response
+3. VS Code opens a diff view showing differences between the two responses
+
+This is useful for comparing responses across environments, before/after changes, or expected vs actual results.
+
+#### Clickable JSON Values
+
+Generate assertions instantly by clicking on JSON values in the response:
+
+1. Expand a response body in the panel
+2. Hover over any value (string, number, boolean, null) - it highlights with a **+** badge
+3. Click to automatically insert an assertion at the end of your sequence
+
+For example, clicking on `"active"` in `{"status": "active"}` generates:
+```bash
+assert $response.body.status == "active"
+```
+
+Works with nested paths and arrays:
+- `body.user.email` → `assert $user.body.user.email == "john@example.com"`
+- `body.items[0].id` → `assert $order.body.items[0].id == 123`
+
 ## CLI Usage
 
 Run tests from the command line for CI/CD pipelines. Only sequences marked with `test` are executed.

package/dist/cli.js

@@ -18582,16 +18582,136 @@ var require_ajv = __commonJS({
 });
 
 // src/schemaGenerator.ts
-function validateAgainstSchema(value, schemaPath, basePath) {
-  try {
-    let resolvedPath = schemaPath;
-    if (!path2.isAbsolute(schemaPath) && basePath) {
-      resolvedPath = path2.resolve(basePath, schemaPath);
+function resolveSchemaPath(schemaPath, basePath, workspaceRoot) {
+  if (schemaPath.startsWith(PATH_ALIAS_PREFIX)) {
+    const relativePath = schemaPath.slice(PATH_ALIAS_PREFIX.length);
+    if (workspaceRoot) {
+      return path2.resolve(workspaceRoot, DEFAULT_CONTRACTS_FOLDER, relativePath);
+    }
+    if (basePath) {
+      let currentDir = basePath;
+      let attempts = 0;
+      while (attempts < 10) {
+        const contractsPath = path2.join(currentDir, DEFAULT_CONTRACTS_FOLDER, relativePath);
+        if (fs.existsSync(path2.dirname(contractsPath))) {
+          return contractsPath;
+        }
+        const parentDir = path2.dirname(currentDir);
+        if (parentDir === currentDir) break;
+        currentDir = parentDir;
+        attempts++;
+      }
+    }
+    if (basePath) {
+      return path2.resolve(basePath, DEFAULT_CONTRACTS_FOLDER, relativePath);
+    }
+    return schemaPath;
+  }
+  if (path2.isAbsolute(schemaPath)) {
+    return schemaPath;
+  }
+  if (basePath) {
+    return path2.resolve(basePath, schemaPath);
+  }
+  return schemaPath;
+}
+function convertAjvError(err, value) {
+  const instancePath = err.instancePath || "(root)";
+  let expected;
+  let actual = void 0;
+  switch (err.keyword) {
+    case "type":
+      expected = err.params.type;
+      actual = getValueAtPath(value, instancePath);
+      break;
+    case "required":
+      expected = `property "${err.params.missingProperty}" to exist`;
+      break;
+    case "enum":
+      expected = `one of: ${err.params.allowedValues?.join(", ")}`;
+      actual = getValueAtPath(value, instancePath);
+      break;
+    case "pattern":
+      expected = `to match pattern "${err.params.pattern}"`;
+      actual = getValueAtPath(value, instancePath);
+      break;
+    case "minLength":
+      expected = `length >= ${err.params.limit}`;
+      actual = getValueAtPath(value, instancePath);
+      break;
+    case "maxLength":
+      expected = `length <= ${err.params.limit}`;
+      actual = getValueAtPath(value, instancePath);
+      break;
+    case "minimum":
+    case "exclusiveMinimum":
+      expected = `>= ${err.params.limit}`;
+      actual = getValueAtPath(value, instancePath);
+      break;
+    case "maximum":
+    case "exclusiveMaximum":
+      expected = `<= ${err.params.limit}`;
+      actual = getValueAtPath(value, instancePath);
+      break;
+    case "additionalProperties":
+      expected = `no additional property "${err.params.additionalProperty}"`;
+      break;
+    case "format":
+      expected = `format "${err.params.format}"`;
+      actual = getValueAtPath(value, instancePath);
+      break;
+    default:
+      if (err.params) {
+        expected = JSON.stringify(err.params);
+      }
+      actual = getValueAtPath(value, instancePath);
+  }
+  let severity = "error";
+  if (err.keyword === "additionalProperties") {
+    severity = "warning";
+  }
+  return {
+    instancePath,
+    schemaPath: err.schemaPath,
+    keyword: err.keyword,
+    message: err.message || "Validation failed",
+    params: err.params,
+    expected,
+    actual,
+    severity
+  };
+}
+function getValueAtPath(obj, jsonPointer) {
+  if (jsonPointer === "(root)" || jsonPointer === "" || jsonPointer === "/") {
+    return obj;
+  }
+  const parts = jsonPointer.replace(/^\//, "").split("/");
+  let current = obj;
+  for (const part of parts) {
+    if (current === null || current === void 0) {
+      return void 0;
     }
+    const key = part.replace(/~1/g, "/").replace(/~0/g, "~");
+    current = current[key];
+  }
+  return current;
+}
+function validateAgainstSchemaDetailed(value, schemaPath, basePath, workspaceRoot) {
+  try {
+    const resolvedPath = resolveSchemaPath(schemaPath, basePath, workspaceRoot);
     if (!fs.existsSync(resolvedPath)) {
       return {
         valid: false,
-        errors: [`Schema file not found: ${schemaPath}`]
+        errors: [{
+          instancePath: "(root)",
+          schemaPath: "",
+          keyword: "file",
+          message: `Schema file not found: ${schemaPath}`,
+          params: { path: schemaPath },
+          severity: "error"
+        }],
+        errorStrings: [`Schema file not found: ${schemaPath}`],
+        resolvedSchemaPath: resolvedPath
       };
     }
     const schemaContent = fs.readFileSync(resolvedPath, "utf-8");
@@ -18601,25 +18721,56 @@ function validateAgainstSchema(value, schemaPath, basePath) {
     } catch (e) {
       return {
         valid: false,
-        errors: [`Invalid JSON in schema file: ${schemaPath}`]
+        errors: [{
+          instancePath: "(root)",
+          schemaPath: "",
+          keyword: "parse",
+          message: `Invalid JSON in schema file: ${schemaPath}`,
+          params: { path: schemaPath },
+          severity: "error"
+        }],
+        errorStrings: [`Invalid JSON in schema file: ${schemaPath}`],
+        resolvedSchemaPath: resolvedPath
       };
     }
     const validate2 = ajv.compile(schema);
     const valid = validate2(value);
     if (!valid && validate2.errors) {
-      const errors = validate2.errors.map((err) => {
+      const errors = validate2.errors.map((err) => convertAjvError(err, value));
+      const errorStrings = validate2.errors.map((err) => {
         const path5 = err.instancePath || "(root)";
         return `${path5}: ${err.message}`;
       });
-      return { valid: false, errors };
+      return {
+        valid: false,
+        errors,
+        errorStrings,
+        resolvedSchemaPath: resolvedPath,
+        schema
+      };
     }
-    return { valid: true };
+    return {
+      valid: true,
+      resolvedSchemaPath: resolvedPath,
+      schema
+    };
   } catch (e) {
     const error = e instanceof Error ? e.message : String(e);
-    return { valid: false, errors: [`Schema validation error: ${error}`] };
+    return {
+      valid: false,
+      errors: [{
+        instancePath: "(root)",
+        schemaPath: "",
+        keyword: "exception",
+        message: `Schema validation error: ${error}`,
+        params: {},
+        severity: "error"
+      }],
+      errorStrings: [`Schema validation error: ${error}`]
+    };
   }
 }
-var import_ajv, fs, path2, ajv;
+var import_ajv, fs, path2, ajv, PATH_ALIAS_PREFIX, DEFAULT_CONTRACTS_FOLDER;
 var init_schemaGenerator = __esm({
   "src/schemaGenerator.ts"() {
     "use strict";
@@ -18627,6 +18778,8 @@ var init_schemaGenerator = __esm({
     fs = __toESM(require("fs"));
     path2 = __toESM(require("path"));
     ajv = new import_ajv.default({ allErrors: true, strict: false });
+    PATH_ALIAS_PREFIX = "@/";
+    DEFAULT_CONTRACTS_FOLDER = "contracts";
   }
 });
 
@@ -18910,7 +19063,7 @@ function evaluateAssertion(assertion, responses, variables, getValueByPath2, res
     if (schemaPath.startsWith('"') && schemaPath.endsWith('"') || schemaPath.startsWith("'") && schemaPath.endsWith("'")) {
       schemaPath = schemaPath.slice(1, -1);
     }
-    const validationResult = validateAgainstSchema(leftValue, schemaPath, basePath);
+    const validationResult = validateAgainstSchemaDetailed(leftValue, schemaPath, basePath);
     const passed2 = validationResult.valid;
     return {
       passed: passed2,
@@ -18921,7 +19074,10 @@ function evaluateAssertion(assertion, responses, variables, getValueByPath2, res
       rightValue: schemaPath,
       leftExpression: assertion.leftExpr,
       rightExpression: assertion.rightExpr,
-      error: !passed2 && validationResult.errors ? validationResult.errors.join("; ") : void 0,
+      error: !passed2 && validationResult.errorStrings ? validationResult.errorStrings.join("; ") : void 0,
+      schemaErrors: validationResult.errors,
+      schemaPath: validationResult.resolvedSchemaPath,
+      schema: validationResult.schema,
       ...!passed2 ? buildFailureContext() : {}
     };
   }
@@ -27691,7 +27847,8 @@ async function runSequenceWithJar(sequenceContent, fileVariables, cookieJar, wor
       const stepResult = {
         type: "assertion",
         stepIndex: stepIdx,
-        assertion: result
+        assertion: result,
+        lineNumber: step.lineNumber
       };
       orderedSteps.push(stepResult);
       const statusIcon = result.passed ? "\u2713" : "\u2717";

package/package.json

@@ -2,7 +2,7 @@
   "name": "norn-cli",
   "displayName": "Norn - REST Client",
   "description": "A powerful REST client for making HTTP requests with sequences, variables, scripts, and cookie support",
-  "version": "1.3.1",
+  "version": "1.3.2",
   "publisher": "Norn-PeterKrustanov",
   "author": {
     "name": "Peter Krastanov"