criterionx-vscode 0.3.1

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2024 Tomas Maritano
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,139 @@
+# Criterion VS Code Extension
+
+VS Code extension for the Criterion decision engine. Provides syntax highlighting, snippets, and validation for Criterion decision files.
+
+## Features
+
+### Syntax Highlighting
+
+Enhanced syntax highlighting for Criterion-specific keywords:
+- `defineDecision`, `createRule`, `createProfileRegistry`
+- Status codes: `OK`, `NO_MATCH`, `INVALID_INPUT`, `INVALID_OUTPUT`
+- Zod schema methods: `z.object`, `z.string`, `z.number`, etc.
+
+### Snippets
+
+Quick snippets to scaffold Criterion code:
+
+| Prefix | Description |
+|--------|-------------|
+| `decision` | Create a new decision |
+| `rule` | Add a rule to a decision |
+| `profile` | Create a profile object |
+| `run` | Run a decision with the engine |
+| `inputSchema` | Define an input schema |
+| `outputSchema` | Define an output schema |
+| `profileSchema` | Define a profile schema |
+| `when` | Create a when condition |
+| `emit` | Create an emit function |
+| `explain` | Create an explain function |
+| `test-decision` | Create a test for a decision |
+| `server` | Create a Criterion server |
+
+### Validation
+
+Real-time validation for Criterion decisions:
+
+- Missing required properties (`id`, `version`, schemas)
+- Empty rules array
+- Missing rule properties (`when`, `emit`, `explain`)
+
+### Hover Documentation
+
+Hover over Criterion keywords to see documentation:
+- `defineDecision`
+- `inputSchema`, `outputSchema`, `profileSchema`
+- `when`, `emit`, `explain`
+
+### Commands
+
+- **Criterion: New Decision** - Create a new decision file with boilerplate
+
+## Installation
+
+### From VS Code Marketplace
+
+Search for "Criterion" in the VS Code Extensions panel.
+
+### Manual Installation
+
+1. Download the `.vsix` file from releases
+2. Open VS Code
+3. Press `Ctrl+Shift+P` / `Cmd+Shift+P`
+4. Run "Extensions: Install from VSIX..."
+5. Select the downloaded file
+
+### Development
+
+```bash
+# Clone the repository
+git clone https://github.com/tomymaritano/criterionx.git
+cd criterionx/packages/vscode-extension
+
+# Install dependencies
+pnpm install
+
+# Build the extension
+pnpm build
+
+# Package the extension
+pnpm package
+```
+
+## Configuration
+
+| Setting | Default | Description |
+|---------|---------|-------------|
+| `criterion.validate` | `true` | Enable/disable validation |
+| `criterion.trace` | `false` | Enable trace logging |
+
+## Supported File Types
+
+- `.criterion.ts` - Dedicated Criterion files
+- `.ts` / `.tsx` - TypeScript files containing `defineDecision` or importing `@criterionx/core`
+
+## Example
+
+```typescript
+import { defineDecision } from "@criterionx/core";
+import { z } from "zod";
+
+export const riskDecision = defineDecision({
+  id: "transaction-risk",
+  version: "1.0.0",
+
+  inputSchema: z.object({
+    amount: z.number(),
+    country: z.string(),
+  }),
+
+  outputSchema: z.object({
+    risk: z.enum(["low", "medium", "high"]),
+    score: z.number(),
+  }),
+
+  profileSchema: z.object({
+    threshold: z.number(),
+    blockedCountries: z.array(z.string()),
+  }),
+
+  rules: [
+    {
+      id: "blocked-country",
+      when: (ctx, profile) => profile.blockedCountries.includes(ctx.country),
+      emit: () => ({ risk: "high", score: 100 }),
+      explain: (ctx) => `Country ${ctx.country} is blocked`,
+    },
+    {
+      id: "default",
+      when: () => true,
+      emit: () => ({ risk: "low", score: 0 }),
+      explain: () => "Default low risk",
+    },
+  ],
+});
+```
+
+## License
+
+MIT

package/dist/extension.js

@@ -0,0 +1,354 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/extension.ts
+var extension_exports = {};
+__export(extension_exports, {
+  activate: () => activate,
+  deactivate: () => deactivate
+});
+module.exports = __toCommonJS(extension_exports);
+var vscode = __toESM(require("vscode"));
+
+// src/validators.ts
+function findBlockEnd(text, start) {
+  let depth = 0;
+  let inString = false;
+  let stringChar = "";
+  for (let i = start; i < text.length; i++) {
+    const char = text[i];
+    const prevChar = i > 0 ? text[i - 1] : "";
+    if (inString) {
+      if (char === stringChar && prevChar !== "\\") {
+        inString = false;
+      }
+      continue;
+    }
+    if (char === '"' || char === "'" || char === "`") {
+      inString = true;
+      stringChar = char;
+      continue;
+    }
+    if (char === "{") {
+      depth++;
+    } else if (char === "}") {
+      depth--;
+      if (depth === 0) {
+        return i + 1;
+      }
+    }
+  }
+  return text.length;
+}
+function findArrayEnd(text, start) {
+  let depth = 0;
+  let inString = false;
+  let stringChar = "";
+  for (let i = start; i < text.length; i++) {
+    const char = text[i];
+    const prevChar = i > 0 ? text[i - 1] : "";
+    if (inString) {
+      if (char === stringChar && prevChar !== "\\") {
+        inString = false;
+      }
+      continue;
+    }
+    if (char === '"' || char === "'" || char === "`") {
+      inString = true;
+      stringChar = char;
+      continue;
+    }
+    if (char === "[") {
+      depth++;
+    } else if (char === "]") {
+      depth--;
+      if (depth === 0) {
+        return i;
+      }
+    }
+  }
+  return text.length;
+}
+function isCriterionContent(fileName, text) {
+  return fileName.endsWith(".criterion.ts") || fileName.endsWith(".ts") && (text.includes("defineDecision") || text.includes("@criterionx/core"));
+}
+function checkMissingId(text) {
+  const diagnostics = [];
+  const defineDecisionRegex = /defineDecision\s*\(\s*\{/g;
+  let match;
+  while ((match = defineDecisionRegex.exec(text)) !== null) {
+    const startPos = match.index;
+    const blockEnd = findBlockEnd(text, startPos);
+    const block = text.slice(startPos, blockEnd);
+    if (!block.includes("id:") && !block.includes("id :")) {
+      diagnostics.push({
+        range: { start: startPos, end: startPos + 14 },
+        message: "Decision is missing required 'id' property",
+        severity: "error"
+      });
+    }
+  }
+  return diagnostics;
+}
+function checkMissingVersion(text) {
+  const diagnostics = [];
+  const defineDecisionRegex = /defineDecision\s*\(\s*\{/g;
+  let match;
+  while ((match = defineDecisionRegex.exec(text)) !== null) {
+    const startPos = match.index;
+    const blockEnd = findBlockEnd(text, startPos);
+    const block = text.slice(startPos, blockEnd);
+    if (!block.includes("version:") && !block.includes("version :")) {
+      diagnostics.push({
+        range: { start: startPos, end: startPos + 14 },
+        message: "Decision is missing required 'version' property",
+        severity: "error"
+      });
+    }
+  }
+  return diagnostics;
+}
+function checkMissingSchemas(text) {
+  const diagnostics = [];
+  const defineDecisionRegex = /defineDecision\s*\(\s*\{/g;
+  let match;
+  while ((match = defineDecisionRegex.exec(text)) !== null) {
+    const startPos = match.index;
+    const blockEnd = findBlockEnd(text, startPos);
+    const block = text.slice(startPos, blockEnd);
+    const schemas = ["inputSchema", "outputSchema", "profileSchema"];
+    for (const schema of schemas) {
+      if (!block.includes(`${schema}:`)) {
+        diagnostics.push({
+          range: { start: startPos, end: startPos + 14 },
+          message: `Decision is missing required '${schema}' property`,
+          severity: "error"
+        });
+      }
+    }
+  }
+  return diagnostics;
+}
+function checkEmptyRules(text) {
+  const diagnostics = [];
+  const emptyRulesRegex = /rules\s*:\s*\[\s*\]/g;
+  let match;
+  while ((match = emptyRulesRegex.exec(text)) !== null) {
+    diagnostics.push({
+      range: { start: match.index, end: match.index + match[0].length },
+      message: "Decision has no rules defined. Add at least one rule.",
+      severity: "warning"
+    });
+  }
+  return diagnostics;
+}
+function checkMissingRuleProperties(text) {
+  const diagnostics = [];
+  const rulesRegex = /rules\s*:\s*\[/g;
+  let rulesMatch;
+  while ((rulesMatch = rulesRegex.exec(text)) !== null) {
+    const rulesStart = rulesMatch.index + rulesMatch[0].length;
+    const rulesEnd = findArrayEnd(text, rulesMatch.index);
+    const rulesBlock = text.slice(rulesStart, rulesEnd);
+    const ruleRegex = /\{\s*id\s*:/g;
+    let ruleMatch;
+    while ((ruleMatch = ruleRegex.exec(rulesBlock)) !== null) {
+      const ruleStart = rulesStart + ruleMatch.index;
+      const ruleEnd = findBlockEnd(text, ruleStart);
+      const ruleBlock = text.slice(ruleStart, ruleEnd);
+      const requiredProps = ["when", "emit", "explain"];
+      for (const prop of requiredProps) {
+        if (!ruleBlock.includes(`${prop}:`)) {
+          diagnostics.push({
+            range: { start: ruleStart, end: ruleStart + 1 },
+            message: `Rule is missing required '${prop}' function`,
+            severity: "error"
+          });
+        }
+      }
+    }
+  }
+  return diagnostics;
+}
+function validateCriterionContent(text) {
+  return [
+    ...checkMissingId(text),
+    ...checkMissingVersion(text),
+    ...checkMissingSchemas(text),
+    ...checkEmptyRules(text),
+    ...checkMissingRuleProperties(text)
+  ];
+}
+var hoverDocs = {
+  defineDecision: "**defineDecision(config)**\n\nCreate a new Criterion decision with type inference.\n\n```typescript\ndefineDecision({\n  id: string,\n  version: string,\n  inputSchema: ZodSchema,\n  outputSchema: ZodSchema,\n  profileSchema: ZodSchema,\n  rules: Rule[]\n})\n```",
+  inputSchema: "**inputSchema**\n\nZod schema defining the input context for this decision.\n\nExample:\n```typescript\ninputSchema: z.object({\n  amount: z.number(),\n  country: z.string()\n})\n```",
+  outputSchema: "**outputSchema**\n\nZod schema defining the output of this decision.\n\nExample:\n```typescript\noutputSchema: z.object({\n  approved: z.boolean(),\n  reason: z.string()\n})\n```",
+  profileSchema: "**profileSchema**\n\nZod schema defining the profile parameters.\n\nExample:\n```typescript\nprofileSchema: z.object({\n  threshold: z.number(),\n  blockedCountries: z.array(z.string())\n})\n```",
+  when: "**when(ctx, profile)**\n\nCondition function that returns true if this rule should match.\n\n```typescript\nwhen: (ctx, profile) => ctx.amount > profile.threshold\n```",
+  emit: "**emit(ctx, profile)**\n\nFunction that returns the output when this rule matches.\n\n```typescript\nemit: (ctx, profile) => ({\n  approved: false,\n  reason: 'Amount too high'\n})\n```",
+  explain: "**explain(ctx, profile)**\n\nFunction that returns a human-readable explanation.\n\n```typescript\nexplain: (ctx) => `Amount ${ctx.amount} exceeded limit`\n```"
+};
+function getHoverDoc(word) {
+  return hoverDocs[word];
+}
+function generateDecisionTemplate(name) {
+  const pascalName = name.split("-").map((s) => s.charAt(0).toUpperCase() + s.slice(1)).join("");
+  const camelName = pascalName.charAt(0).toLowerCase() + pascalName.slice(1);
+  return `import { defineDecision } from "@criterionx/core";
+import { z } from "zod";
+
+/**
+ * ${pascalName} Decision
+ */
+export const ${camelName} = defineDecision({
+  id: "${name}",
+  version: "1.0.0",
+
+  inputSchema: z.object({
+    // TODO: Define input schema
+    value: z.string(),
+  }),
+
+  outputSchema: z.object({
+    // TODO: Define output schema
+    result: z.string(),
+  }),
+
+  profileSchema: z.object({
+    // TODO: Define profile schema
+  }),
+
+  rules: [
+    {
+      id: "default",
+      when: () => true,
+      emit: () => ({ result: "OK" }),
+      explain: () => "Default rule",
+    },
+  ],
+});
+`;
+}
+
+// src/extension.ts
+var diagnosticCollection;
+function activate(context) {
+  console.log("Criterion extension activated");
+  diagnosticCollection = vscode.languages.createDiagnosticCollection("criterion");
+  context.subscriptions.push(diagnosticCollection);
+  const config = vscode.workspace.getConfiguration("criterion");
+  if (config.get("validate", true)) {
+    context.subscriptions.push(
+      vscode.workspace.onDidChangeTextDocument((event) => {
+        if (isCriterionContent(event.document.fileName, event.document.getText())) {
+          validateDocument(event.document);
+        }
+      })
+    );
+    context.subscriptions.push(
+      vscode.workspace.onDidOpenTextDocument((document) => {
+        if (isCriterionContent(document.fileName, document.getText())) {
+          validateDocument(document);
+        }
+      })
+    );
+    vscode.workspace.textDocuments.forEach((document) => {
+      if (isCriterionContent(document.fileName, document.getText())) {
+        validateDocument(document);
+      }
+    });
+  }
+  context.subscriptions.push(
+    vscode.languages.registerHoverProvider(
+      ["typescript", "typescriptreact"],
+      new CriterionHoverProvider()
+    )
+  );
+  context.subscriptions.push(
+    vscode.commands.registerCommand("criterion.newDecision", createNewDecision)
+  );
+}
+function deactivate() {
+  if (diagnosticCollection) {
+    diagnosticCollection.dispose();
+  }
+}
+function validateDocument(document) {
+  const text = document.getText();
+  const diagnostics = validateCriterionContent(text);
+  const vscodeDiagnostics = diagnostics.map((d) => convertDiagnostic(d, document));
+  diagnosticCollection.set(document.uri, vscodeDiagnostics);
+}
+function convertDiagnostic(diagnostic, document) {
+  const startPos = document.positionAt(diagnostic.range.start);
+  const endPos = document.positionAt(diagnostic.range.end);
+  const range = new vscode.Range(startPos, endPos);
+  const severity = diagnostic.severity === "error" ? vscode.DiagnosticSeverity.Error : diagnostic.severity === "warning" ? vscode.DiagnosticSeverity.Warning : vscode.DiagnosticSeverity.Information;
+  return new vscode.Diagnostic(range, diagnostic.message, severity);
+}
+var CriterionHoverProvider = class {
+  provideHover(document, position) {
+    const range = document.getWordRangeAtPosition(position);
+    if (!range) return null;
+    const word = document.getText(range);
+    const doc = getHoverDoc(word);
+    if (doc) {
+      return new vscode.Hover(new vscode.MarkdownString(doc));
+    }
+    return null;
+  }
+};
+async function createNewDecision() {
+  const name = await vscode.window.showInputBox({
+    prompt: "Enter decision name (e.g., risk-assessment)",
+    placeHolder: "decision-name"
+  });
+  if (!name) return;
+  const fileName = `${name}.criterion.ts`;
+  const content = generateDecisionTemplate(name);
+  const workspaceFolder = vscode.workspace.workspaceFolders?.[0];
+  if (!workspaceFolder) {
+    vscode.window.showErrorMessage("No workspace folder open");
+    return;
+  }
+  const uri = vscode.Uri.joinPath(workspaceFolder.uri, fileName);
+  try {
+    await vscode.workspace.fs.writeFile(uri, Buffer.from(content));
+    const doc = await vscode.workspace.openTextDocument(uri);
+    await vscode.window.showTextDocument(doc);
+    vscode.window.showInformationMessage(`Created ${fileName}`);
+  } catch (error) {
+    vscode.window.showErrorMessage(`Failed to create file: ${error}`);
+  }
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  activate,
+  deactivate
+});

package/language-configuration.json

@@ -0,0 +1,37 @@
+{
+  "comments": {
+    "lineComment": "//",
+    "blockComment": ["/*", "*/"]
+  },
+  "brackets": [
+    ["{", "}"],
+    ["[", "]"],
+    ["(", ")"]
+  ],
+  "autoClosingPairs": [
+    { "open": "{", "close": "}" },
+    { "open": "[", "close": "]" },
+    { "open": "(", "close": ")" },
+    { "open": "'", "close": "'", "notIn": ["string", "comment"] },
+    { "open": "\"", "close": "\"", "notIn": ["string"] },
+    { "open": "`", "close": "`", "notIn": ["string", "comment"] }
+  ],
+  "surroundingPairs": [
+    ["{", "}"],
+    ["[", "]"],
+    ["(", ")"],
+    ["'", "'"],
+    ["\"", "\""],
+    ["`", "`"]
+  ],
+  "folding": {
+    "markers": {
+      "start": "^\\s*//\\s*#?region\\b",
+      "end": "^\\s*//\\s*#?endregion\\b"
+    }
+  },
+  "indentationRules": {
+    "increaseIndentPattern": "^((?!\\/\\/).)*(\\{[^}\"'`]*|\\([^)\"'`]*|\\[[^\\]\"'`]*)$",
+    "decreaseIndentPattern": "^((?!.*?\\/\\*).*\\*/)?\\s*[\\}\\]].*$"
+  }
+}

package/package.json

@@ -0,0 +1,108 @@
+{
+  "name": "criterionx-vscode",
+  "displayName": "Criterion",
+  "description": "VS Code extension for Criterion decision engine - syntax highlighting, snippets, and validation",
+  "version": "0.3.1",
+  "publisher": "criterionx",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/tomymaritano/criterionx.git",
+    "directory": "packages/vscode-extension"
+  },
+  "engines": {
+    "vscode": "^1.85.0"
+  },
+  "categories": [
+    "Programming Languages",
+    "Snippets",
+    "Linters"
+  ],
+  "keywords": [
+    "criterion",
+    "decision-engine",
+    "rules-engine",
+    "typescript"
+  ],
+  "activationEvents": [
+    "onLanguage:typescript",
+    "onLanguage:typescriptreact"
+  ],
+  "main": "./dist/extension.js",
+  "contributes": {
+    "languages": [
+      {
+        "id": "criterion",
+        "aliases": [
+          "Criterion",
+          "criterion"
+        ],
+        "extensions": [
+          ".criterion.ts"
+        ],
+        "configuration": "./language-configuration.json"
+      }
+    ],
+    "grammars": [
+      {
+        "language": "criterion",
+        "scopeName": "source.criterion",
+        "path": "./syntaxes/criterion.tmLanguage.json"
+      },
+      {
+        "scopeName": "source.criterion.injection",
+        "path": "./syntaxes/criterion-injection.tmLanguage.json",
+        "injectTo": [
+          "source.ts",
+          "source.tsx"
+        ]
+      }
+    ],
+    "snippets": [
+      {
+        "language": "typescript",
+        "path": "./snippets/criterion.json"
+      },
+      {
+        "language": "typescriptreact",
+        "path": "./snippets/criterion.json"
+      },
+      {
+        "language": "criterion",
+        "path": "./snippets/criterion.json"
+      }
+    ],
+    "configuration": {
+      "title": "Criterion",
+      "properties": {
+        "criterion.validate": {
+          "type": "boolean",
+          "default": true,
+          "description": "Enable/disable validation of Criterion decision files"
+        },
+        "criterion.trace": {
+          "type": "boolean",
+          "default": false,
+          "description": "Enable trace logging for debugging"
+        }
+      }
+    }
+  },
+  "devDependencies": {
+    "@types/node": "^20.0.0",
+    "@types/vscode": "^1.85.0",
+    "@vscode/vsce": "^2.22.0",
+    "tsup": "^8.0.0",
+    "typescript": "^5.3.0",
+    "vitest": "^4.0.0"
+  },
+  "scripts": {
+    "build": "tsup src/extension.ts --format cjs --out-dir dist --clean --external vscode",
+    "watch": "tsup src/extension.ts --format cjs --out-dir dist --watch --external vscode",
+    "test": "vitest run",
+    "test:watch": "vitest",
+    "test:coverage": "vitest run --coverage",
+    "package": "vsce package",
+    "typecheck": "tsc --noEmit"
+  }
+}