criterionx-vscode 0.3.1

package/snippets/criterion.json

@@ -0,0 +1,213 @@
+{
+  "Define Decision": {
+    "prefix": ["decision", "defineDecision", "crit-decision"],
+    "description": "Create a new Criterion decision",
+    "body": [
+      "import { defineDecision } from \"@criterionx/core\";",
+      "import { z } from \"zod\";",
+      "",
+      "export const ${1:myDecision} = defineDecision({",
+      "  id: \"${2:decision-id}\",",
+      "  version: \"${3:1.0.0}\",",
+      "",
+      "  inputSchema: z.object({",
+      "    ${4:field}: z.${5:string}(),",
+      "  }),",
+      "",
+      "  outputSchema: z.object({",
+      "    ${6:result}: z.${7:string}(),",
+      "  }),",
+      "",
+      "  profileSchema: z.object({",
+      "    ${8:threshold}: z.${9:number}(),",
+      "  }),",
+      "",
+      "  rules: [",
+      "    {",
+      "      id: \"${10:default}\",",
+      "      when: (ctx, profile) => ${11:true},",
+      "      emit: (ctx, profile) => ({ ${6:result}: \"${12:value}\" }),",
+      "      explain: (ctx, profile) => \"${13:Explanation}\",",
+      "    },",
+      "  ],",
+      "});",
+      ""
+    ]
+  },
+  "Create Rule": {
+    "prefix": ["rule", "crit-rule"],
+    "description": "Create a new rule for a Criterion decision",
+    "body": [
+      "{",
+      "  id: \"${1:rule-id}\",",
+      "  when: (ctx, profile) => ${2:ctx.value > profile.threshold},",
+      "  emit: (ctx, profile) => ({",
+      "    ${3:result}: \"${4:value}\",",
+      "  }),",
+      "  explain: (ctx, profile) => `${5:Rule matched because \\${ctx.value\\}}`",
+      "},"
+    ]
+  },
+  "Create Profile": {
+    "prefix": ["profile", "crit-profile"],
+    "description": "Create a profile for a Criterion decision",
+    "body": [
+      "const ${1:defaultProfile} = {",
+      "  ${2:threshold}: ${3:1000},",
+      "  ${4:enabled}: ${5:true},",
+      "} satisfies z.infer<typeof ${6:myDecision}.profileSchema>;"
+    ]
+  },
+  "Run Decision": {
+    "prefix": ["run", "crit-run", "engine.run"],
+    "description": "Run a Criterion decision",
+    "body": [
+      "import { Engine } from \"@criterionx/core\";",
+      "",
+      "const engine = new Engine();",
+      "",
+      "const result = engine.run(",
+      "  ${1:myDecision},",
+      "  { ${2:input}: ${3:value} },",
+      "  { profile: ${4:defaultProfile} }",
+      ");",
+      "",
+      "if (result.status === \"OK\") {",
+      "  console.log(result.data);",
+      "}"
+    ]
+  },
+  "Input Schema": {
+    "prefix": ["inputSchema", "crit-input"],
+    "description": "Define an input schema with Zod",
+    "body": [
+      "inputSchema: z.object({",
+      "  ${1:field}: z.${2:string}(),",
+      "  ${3:amount}: z.${4:number}(),",
+      "}),"
+    ]
+  },
+  "Output Schema": {
+    "prefix": ["outputSchema", "crit-output"],
+    "description": "Define an output schema with Zod",
+    "body": [
+      "outputSchema: z.object({",
+      "  ${1:result}: z.${2:string}(),",
+      "  ${3:score}: z.${4:number}(),",
+      "}),"
+    ]
+  },
+  "Profile Schema": {
+    "prefix": ["profileSchema", "crit-profile-schema"],
+    "description": "Define a profile schema with Zod",
+    "body": [
+      "profileSchema: z.object({",
+      "  ${1:threshold}: z.number(),",
+      "  ${2:enabled}: z.boolean().default(true),",
+      "}),"
+    ]
+  },
+  "When Condition": {
+    "prefix": ["when", "crit-when"],
+    "description": "Create a when condition for a rule",
+    "body": [
+      "when: (ctx, profile) => ${1:ctx.amount > profile.threshold},"
+    ]
+  },
+  "Emit Output": {
+    "prefix": ["emit", "crit-emit"],
+    "description": "Create an emit function for a rule",
+    "body": [
+      "emit: (ctx, profile) => ({",
+      "  ${1:result}: \"${2:value}\",",
+      "  ${3:score}: ${4:ctx.amount / profile.threshold},",
+      "}),"
+    ]
+  },
+  "Explain Function": {
+    "prefix": ["explain", "crit-explain"],
+    "description": "Create an explain function for a rule",
+    "body": [
+      "explain: (ctx, profile) => `${1:Matched because \\${ctx.field\\} is \\${ctx.value\\}}`,"
+    ]
+  },
+  "Decision with Meta": {
+    "prefix": ["decision-meta", "crit-decision-full"],
+    "description": "Create a decision with metadata",
+    "body": [
+      "import { defineDecision } from \"@criterionx/core\";",
+      "import { z } from \"zod\";",
+      "",
+      "export const ${1:myDecision} = defineDecision({",
+      "  id: \"${2:decision-id}\",",
+      "  version: \"${3:1.0.0}\",",
+      "",
+      "  meta: {",
+      "    owner: \"${4:team-name}\",",
+      "    tags: [\"${5:risk}\", \"${6:finance}\"],",
+      "    tier: \"${7:critical}\",",
+      "    description: \"${8:Decision description}\",",
+      "  },",
+      "",
+      "  inputSchema: z.object({",
+      "    ${9:field}: z.string(),",
+      "  }),",
+      "",
+      "  outputSchema: z.object({",
+      "    ${10:result}: z.string(),",
+      "  }),",
+      "",
+      "  profileSchema: z.object({",
+      "    ${11:threshold}: z.number(),",
+      "  }),",
+      "",
+      "  rules: [",
+      "    $0",
+      "  ],",
+      "});",
+      ""
+    ]
+  },
+  "Test Decision": {
+    "prefix": ["test-decision", "crit-test"],
+    "description": "Create a test for a Criterion decision",
+    "body": [
+      "import { testDecision } from \"@criterionx/testing\";",
+      "import { ${1:myDecision} } from \"./${2:decisions}\";",
+      "",
+      "const result = testDecision(${1:myDecision}, {",
+      "  profile: ${3:defaultProfile},",
+      "  cases: [",
+      "    {",
+      "      name: \"${4:test case}\",",
+      "      input: { ${5:field}: ${6:value} },",
+      "      expected: { status: \"OK\", ruleId: \"${7:rule-id}\" },",
+      "    },",
+      "  ],",
+      "  expect: {",
+      "    noUnreachableRules: true,",
+      "  },",
+      "});",
+      "",
+      "console.log(result.passed ? \"PASSED\" : \"FAILED\");"
+    ]
+  },
+  "Server Setup": {
+    "prefix": ["server", "crit-server"],
+    "description": "Create a Criterion server",
+    "body": [
+      "import { createServer } from \"@criterionx/server\";",
+      "import { ${1:myDecision} } from \"./${2:decisions}\";",
+      "",
+      "const server = createServer({",
+      "  decisions: [${1:myDecision}],",
+      "  profiles: {",
+      "    \"${3:decision-id}\": ${4:defaultProfile},",
+      "  },",
+      "});",
+      "",
+      "server.listen(${5:3000});",
+      "console.log(\"Server running on http://localhost:${5:3000}\");"
+    ]
+  }
+}

package/src/extension.ts

@@ -0,0 +1,156 @@
+import * as vscode from "vscode";
+import {
+  isCriterionContent,
+  validateCriterionContent,
+  getHoverDoc,
+  generateDecisionTemplate,
+  type Diagnostic,
+} from "./validators";
+
+/**
+ * Criterion VS Code Extension
+ *
+ * Provides syntax highlighting, snippets, and basic validation
+ * for Criterion decision files.
+ */
+
+let diagnosticCollection: vscode.DiagnosticCollection;
+
+export function activate(context: vscode.ExtensionContext) {
+  console.log("Criterion extension activated");
+
+  // Create diagnostic collection for validation errors
+  diagnosticCollection = vscode.languages.createDiagnosticCollection("criterion");
+  context.subscriptions.push(diagnosticCollection);
+
+  // Register document change listener for validation
+  const config = vscode.workspace.getConfiguration("criterion");
+  if (config.get("validate", true)) {
+    // Validate on document change
+    context.subscriptions.push(
+      vscode.workspace.onDidChangeTextDocument((event) => {
+        if (isCriterionContent(event.document.fileName, event.document.getText())) {
+          validateDocument(event.document);
+        }
+      })
+    );
+
+    // Validate on document open
+    context.subscriptions.push(
+      vscode.workspace.onDidOpenTextDocument((document) => {
+        if (isCriterionContent(document.fileName, document.getText())) {
+          validateDocument(document);
+        }
+      })
+    );
+
+    // Validate all open documents on activation
+    vscode.workspace.textDocuments.forEach((document) => {
+      if (isCriterionContent(document.fileName, document.getText())) {
+        validateDocument(document);
+      }
+    });
+  }
+
+  // Register hover provider for Criterion keywords
+  context.subscriptions.push(
+    vscode.languages.registerHoverProvider(
+      ["typescript", "typescriptreact"],
+      new CriterionHoverProvider()
+    )
+  );
+
+  // Register command to create a new decision
+  context.subscriptions.push(
+    vscode.commands.registerCommand("criterion.newDecision", createNewDecision)
+  );
+}
+
+export function deactivate() {
+  if (diagnosticCollection) {
+    diagnosticCollection.dispose();
+  }
+}
+
+/**
+ * Validate a Criterion document
+ */
+function validateDocument(document: vscode.TextDocument): void {
+  const text = document.getText();
+  const diagnostics = validateCriterionContent(text);
+
+  const vscodeDiagnostics = diagnostics.map((d) => convertDiagnostic(d, document));
+  diagnosticCollection.set(document.uri, vscodeDiagnostics);
+}
+
+/**
+ * Convert internal diagnostic to VS Code diagnostic
+ */
+function convertDiagnostic(diagnostic: Diagnostic, document: vscode.TextDocument): vscode.Diagnostic {
+  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);
+}
+
+/**
+ * Hover provider for Criterion keywords
+ */
+class CriterionHoverProvider implements vscode.HoverProvider {
+  provideHover(
+    document: vscode.TextDocument,
+    position: vscode.Position
+  ): vscode.Hover | null {
+    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;
+  }
+}
+
+/**
+ * Command to create a new decision file
+ */
+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}`);
+  }
+}

package/src/validators.test.ts

@@ -0,0 +1,340 @@
+import { describe, it, expect } from "vitest";
+import {
+  findBlockEnd,
+  findArrayEnd,
+  isCriterionContent,
+  checkMissingId,
+  checkMissingVersion,
+  checkMissingSchemas,
+  checkEmptyRules,
+  checkMissingRuleProperties,
+  validateCriterionContent,
+  getHoverDoc,
+  generateDecisionTemplate,
+  hoverDocs,
+} from "./validators";
+
+describe("validators", () => {
+  describe("findBlockEnd", () => {
+    it("finds end of simple block", () => {
+      const text = "{ foo: 1 }";
+      expect(findBlockEnd(text, 0)).toBe(10);
+    });
+
+    it("handles nested blocks", () => {
+      const text = "{ foo: { bar: 1 } }";
+      expect(findBlockEnd(text, 0)).toBe(19);
+    });
+
+    it("handles strings with braces", () => {
+      const text = '{ foo: "{ not a block }" }';
+      expect(findBlockEnd(text, 0)).toBe(26);
+    });
+
+    it("handles template literals with braces", () => {
+      const text = "{ foo: `{ template }` }";
+      expect(findBlockEnd(text, 0)).toBe(23);
+    });
+
+    it("handles escaped quotes in strings", () => {
+      const text = '{ foo: "escaped \\" quote" }';
+      expect(findBlockEnd(text, 0)).toBe(27);
+    });
+
+    it("returns text length if no closing brace", () => {
+      const text = "{ foo: 1";
+      expect(findBlockEnd(text, 0)).toBe(8);
+    });
+  });
+
+  describe("findArrayEnd", () => {
+    it("finds end of simple array", () => {
+      const text = "[1, 2, 3]";
+      expect(findArrayEnd(text, 0)).toBe(8);
+    });
+
+    it("handles nested arrays", () => {
+      const text = "[[1, 2], [3, 4]]";
+      expect(findArrayEnd(text, 0)).toBe(15);
+    });
+
+    it("handles strings with brackets", () => {
+      const text = '["[ not an array ]"]';
+      expect(findArrayEnd(text, 0)).toBe(19);
+    });
+
+    it("handles mixed nesting", () => {
+      const text = '[{ arr: [1] }, "text"]';
+      expect(findArrayEnd(text, 0)).toBe(21);
+    });
+
+    it("returns text length if no closing bracket", () => {
+      const text = "[1, 2";
+      expect(findArrayEnd(text, 0)).toBe(5);
+    });
+  });
+
+  describe("isCriterionContent", () => {
+    it("returns true for .criterion.ts files", () => {
+      expect(isCriterionContent("risk.criterion.ts", "")).toBe(true);
+    });
+
+    it("returns true for .ts files with defineDecision", () => {
+      expect(isCriterionContent("rules.ts", "defineDecision({})")).toBe(true);
+    });
+
+    it("returns true for .ts files with @criterionx/core import", () => {
+      expect(
+        isCriterionContent("rules.ts", 'import { Engine } from "@criterionx/core"')
+      ).toBe(true);
+    });
+
+    it("returns false for non-criterion .ts files", () => {
+      expect(isCriterionContent("utils.ts", "function foo() {}")).toBe(false);
+    });
+
+    it("returns false for non-.ts files", () => {
+      expect(isCriterionContent("readme.md", "defineDecision")).toBe(false);
+    });
+  });
+
+  describe("checkMissingId", () => {
+    it("returns error for decision without id", () => {
+      const text = `
+        defineDecision({
+          version: "1.0.0",
+          inputSchema: z.object({}),
+          outputSchema: z.object({}),
+          profileSchema: z.object({}),
+          rules: []
+        })
+      `;
+      const diagnostics = checkMissingId(text);
+      expect(diagnostics).toHaveLength(1);
+      expect(diagnostics[0].message).toBe("Decision is missing required 'id' property");
+      expect(diagnostics[0].severity).toBe("error");
+    });
+
+    it("returns empty for decision with id", () => {
+      const text = `
+        defineDecision({
+          id: "my-decision",
+          version: "1.0.0"
+        })
+      `;
+      const diagnostics = checkMissingId(text);
+      expect(diagnostics).toHaveLength(0);
+    });
+
+    it("handles id with space before colon", () => {
+      const text = `defineDecision({ id : "test" })`;
+      const diagnostics = checkMissingId(text);
+      expect(diagnostics).toHaveLength(0);
+    });
+  });
+
+  describe("checkMissingVersion", () => {
+    it("returns error for decision without version", () => {
+      const text = `
+        defineDecision({
+          id: "test"
+        })
+      `;
+      const diagnostics = checkMissingVersion(text);
+      expect(diagnostics).toHaveLength(1);
+      expect(diagnostics[0].message).toBe("Decision is missing required 'version' property");
+    });
+
+    it("returns empty for decision with version", () => {
+      const text = `defineDecision({ version: "1.0.0" })`;
+      const diagnostics = checkMissingVersion(text);
+      expect(diagnostics).toHaveLength(0);
+    });
+  });
+
+  describe("checkMissingSchemas", () => {
+    it("returns errors for missing schemas", () => {
+      const text = `
+        defineDecision({
+          id: "test",
+          version: "1.0.0"
+        })
+      `;
+      const diagnostics = checkMissingSchemas(text);
+      expect(diagnostics).toHaveLength(3);
+      expect(diagnostics.map((d) => d.message)).toContain(
+        "Decision is missing required 'inputSchema' property"
+      );
+      expect(diagnostics.map((d) => d.message)).toContain(
+        "Decision is missing required 'outputSchema' property"
+      );
+      expect(diagnostics.map((d) => d.message)).toContain(
+        "Decision is missing required 'profileSchema' property"
+      );
+    });
+
+    it("returns empty for decision with all schemas", () => {
+      const text = `
+        defineDecision({
+          inputSchema: z.object({}),
+          outputSchema: z.object({}),
+          profileSchema: z.object({})
+        })
+      `;
+      const diagnostics = checkMissingSchemas(text);
+      expect(diagnostics).toHaveLength(0);
+    });
+  });
+
+  describe("checkEmptyRules", () => {
+    it("returns warning for empty rules array", () => {
+      const text = `rules: []`;
+      const diagnostics = checkEmptyRules(text);
+      expect(diagnostics).toHaveLength(1);
+      expect(diagnostics[0].message).toBe("Decision has no rules defined. Add at least one rule.");
+      expect(diagnostics[0].severity).toBe("warning");
+    });
+
+    it("returns warning for empty rules with whitespace", () => {
+      const text = `rules: [   ]`;
+      const diagnostics = checkEmptyRules(text);
+      expect(diagnostics).toHaveLength(1);
+    });
+
+    it("returns empty for non-empty rules", () => {
+      const text = `rules: [{ id: "test" }]`;
+      const diagnostics = checkEmptyRules(text);
+      expect(diagnostics).toHaveLength(0);
+    });
+  });
+
+  describe("checkMissingRuleProperties", () => {
+    it("returns errors for rule missing required properties", () => {
+      const text = `
+        rules: [
+          {
+            id: "test"
+          }
+        ]
+      `;
+      const diagnostics = checkMissingRuleProperties(text);
+      expect(diagnostics).toHaveLength(3);
+      expect(diagnostics.map((d) => d.message)).toContain("Rule is missing required 'when' function");
+      expect(diagnostics.map((d) => d.message)).toContain("Rule is missing required 'emit' function");
+      expect(diagnostics.map((d) => d.message)).toContain(
+        "Rule is missing required 'explain' function"
+      );
+    });
+
+    it("returns empty for complete rule", () => {
+      const text = `
+        rules: [
+          {
+            id: "test",
+            when: () => true,
+            emit: () => ({}),
+            explain: () => "test"
+          }
+        ]
+      `;
+      const diagnostics = checkMissingRuleProperties(text);
+      expect(diagnostics).toHaveLength(0);
+    });
+  });
+
+  describe("validateCriterionContent", () => {
+    it("returns all diagnostics for invalid decision", () => {
+      const text = `
+        defineDecision({
+          rules: []
+        })
+      `;
+      const diagnostics = validateCriterionContent(text);
+      // Missing: id, version, inputSchema, outputSchema, profileSchema + empty rules warning
+      expect(diagnostics.length).toBeGreaterThan(0);
+    });
+
+    it("returns empty for valid decision", () => {
+      const text = `
+        defineDecision({
+          id: "test",
+          version: "1.0.0",
+          inputSchema: z.object({}),
+          outputSchema: z.object({}),
+          profileSchema: z.object({}),
+          rules: [
+            {
+              id: "default",
+              when: () => true,
+              emit: () => ({}),
+              explain: () => "Default"
+            }
+          ]
+        })
+      `;
+      const diagnostics = validateCriterionContent(text);
+      expect(diagnostics).toHaveLength(0);
+    });
+  });
+
+  describe("getHoverDoc", () => {
+    it("returns documentation for known keywords", () => {
+      expect(getHoverDoc("defineDecision")).toContain("Create a new Criterion decision");
+      expect(getHoverDoc("inputSchema")).toContain("Zod schema defining the input");
+      expect(getHoverDoc("when")).toContain("Condition function");
+      expect(getHoverDoc("emit")).toContain("Function that returns the output");
+      expect(getHoverDoc("explain")).toContain("human-readable explanation");
+    });
+
+    it("returns undefined for unknown keywords", () => {
+      expect(getHoverDoc("unknownKeyword")).toBeUndefined();
+      expect(getHoverDoc("")).toBeUndefined();
+    });
+  });
+
+  describe("hoverDocs", () => {
+    it("has documentation for all expected keywords", () => {
+      const expectedKeywords = [
+        "defineDecision",
+        "inputSchema",
+        "outputSchema",
+        "profileSchema",
+        "when",
+        "emit",
+        "explain",
+      ];
+      for (const keyword of expectedKeywords) {
+        expect(hoverDocs[keyword]).toBeDefined();
+      }
+    });
+  });
+
+  describe("generateDecisionTemplate", () => {
+    it("generates valid decision template", () => {
+      const template = generateDecisionTemplate("risk-assessment");
+      expect(template).toContain('import { defineDecision } from "@criterionx/core"');
+      expect(template).toContain('import { z } from "zod"');
+      expect(template).toContain("RiskAssessment Decision");
+      expect(template).toContain("export const riskAssessment");
+      expect(template).toContain('id: "risk-assessment"');
+      expect(template).toContain('version: "1.0.0"');
+      expect(template).toContain("inputSchema:");
+      expect(template).toContain("outputSchema:");
+      expect(template).toContain("profileSchema:");
+      expect(template).toContain("rules:");
+    });
+
+    it("handles single-word names", () => {
+      const template = generateDecisionTemplate("approval");
+      expect(template).toContain("Approval Decision");
+      expect(template).toContain("export const approval");
+      expect(template).toContain('id: "approval"');
+    });
+
+    it("handles multi-word names", () => {
+      const template = generateDecisionTemplate("loan-risk-assessment");
+      expect(template).toContain("LoanRiskAssessment Decision");
+      expect(template).toContain("export const loanRiskAssessment");
+    });
+  });
+});