@lexq/cli 0.1.23 → 0.1.26

package/README.md

@@ -53,48 +53,24 @@ lexq auth login
 # 2. Verify
 lexq auth whoami
 
-# 3. Create a policy group
-lexq groups create --json '{"name":"my-policy","priority":0}'
-
-# 4. Create a draft version
-lexq versions create --group-id <GROUP_ID> --json '{"commitMessage":"v1"}'
-
-# 5. Add a rule
-lexq rules create --group-id <GROUP_ID> --version-id <VERSION_ID> --json '{
-  "name": "VIP Discount",
-  "priority": 0,
-  "condition": {
-    "type": "SINGLE",
-    "field": "customer_tier",
-    "operator": "EQUALS",
-    "value": "VIP",
-    "valueType": "STRING"
-  },
-  "actions": [{
-    "type": "MUTATE_FACT",
-    "parameters": {
-      "method": "PERCENTAGE",
-      "rate": 10,
-      "refVar": "payment_amount",
-      "operator": "SUB",
-      "rounding": { "mode": "HALF_UP", "scale": 0 }
-    }
-  }]
-}'
+# 3. Start from a domain template — provisions facts, sample rules, and a policy group
+lexq domain-templates list
+lexq domain-templates apply --template ECOMMERCE
+# Returns: policyGroupId, policyVersionId, factsCreated, rulesCreated
 
-# 6. Test against your data before shipping
+# 4. Test a rule against your data before shipping
 lexq analytics dry-run --version-id <VERSION_ID> --debug --mock \
-  --json '{"facts":{"customer_tier":"VIP","payment_amount":100000}}'
+  --json '{"facts":{"loyalty_tier":"PLATINUM","purchase_subtotal_usd":150}}'
 
-# 7. Deploy
+# 5. Deploy
 lexq deploy publish --group-id <GROUP_ID> --version-id <VERSION_ID> --memo "v1"
 lexq deploy live --group-id <GROUP_ID> --version-id <VERSION_ID> --memo "Initial deploy"
 ```
 
-## For AI Agents — 63 MCP Tools
+## For AI Agents — the Complete Partner API
 
-LexQ is designed to be AI-native. The entire policy engine API — all 63 tools
-— is exposed via Model Context Protocol. Claude, Cursor, and other MCP-compatible
+LexQ is designed to be AI-native. The entire policy engine Partner API is
+exposed via Model Context Protocol. Claude, Cursor, and other MCP-compatible
 agents can create, simulate, and deploy rules autonomously, with human approval
 before production.
 
@@ -103,7 +79,7 @@ before production.
 1. **Settings → Connectors → Add Custom Integration**
 2. Enter: `https://mcp.lexq.io`
 3. Sign in with your LexQ account and select an API key
-4. Done — 63 tools available in every conversation
+4. Done — the full toolset available in every conversation
 
 ### Remote (Streamable HTTP)
 
@@ -210,6 +186,7 @@ lexq groups ab-test        start | stop | adjust
 lexq versions              list | get | create | update | delete | clone
 lexq rules                 list | get | create | update | delete | reorder | toggle
 lexq facts                 list | create | update | delete | action-metadata
+lexq domain-templates      list | preview | apply
 lexq deploy                publish | live | rollback | undeploy | history | detail | overview | deployable | diff
 lexq analytics             dry-run | dry-run-compare | requirements
 lexq analytics simulation  start | status | list | cancel | export

package/dist/index.js

@@ -3910,6 +3910,51 @@ function registerWebhookSubscriptionTools(server, callApi) {
   );
 }
 
+// src/mcp/tools/domain-templates.ts
+import { z as z11 } from "zod";
+function registerDomainTemplateTools(server, callApi) {
+  server.registerTool(
+    "lexq_domain_templates_list",
+    {
+      title: "List Domain Templates",
+      description: "List all domain templates. A domain template is a curated, industry-specific starter pack of fact definitions and sample rules (e.g. ECOMMERCE). Each entry reports its key, status (ACTIVE or COMING_SOON), and a summary of what it provisions. Call this before preview or apply to discover which templates can currently be applied.",
+      inputSchema: {}
+    },
+    async () => callApi("GET", "domain-templates")
+  );
+  server.registerTool(
+    "lexq_domain_templates_preview",
+    {
+      title: "Preview Domain Template",
+      description: "Preview exactly what a domain template will provision before applying it: the fact definitions it registers, the sample rules it creates, and an apply plan. This is a read-only dry run \u2014 nothing is created. Only ACTIVE templates can be previewed.",
+      inputSchema: {
+        template: z11.string().describe(
+          "Domain template key (e.g. ECOMMERCE). Use lexq_domain_templates_list to see available keys \u2014 currently only ECOMMERCE is ACTIVE."
+        )
+      }
+    },
+    async ({ template }) => callApi("GET", `domain-templates/${template}/preview`)
+  );
+  server.registerTool(
+    "lexq_domain_templates_apply",
+    {
+      title: "Apply Domain Template",
+      description: "Apply a domain template to the current tenant. Creates the template's fact definitions and a new policy group pre-populated with its sample rules as a DRAFT version. Existing facts are skipped \u2014 apply is additive and never overwrites existing schema. Run lexq_domain_templates_preview first to review what will be created. Only ACTIVE templates can be applied.",
+      inputSchema: {
+        template: z11.string().describe("Domain template key to apply (e.g. ECOMMERCE)."),
+        customName: z11.string().optional().describe(
+          "Optional custom name for the policy group that gets created. If omitted, the template's default name is used."
+        )
+      }
+    },
+    async ({ template, customName }) => {
+      const body = {};
+      if (customName !== void 0) body.customName = customName;
+      return callApi("POST", `domain-templates/${template}/apply`, { body });
+    }
+  );
+}
+
 // src/mcp/register.ts
 function registerAllTools(server, callApi) {
   registerStatusTools(server, callApi);
@@ -3922,6 +3967,7 @@ function registerAllTools(server, callApi) {
   registerHistoryTools(server, callApi);
   registerIntegrationTools(server, callApi);
   registerLogTools(server, callApi);
+  registerDomainTemplateTools(server, callApi);
   registerWebhookSubscriptionTools(server, callApi);
 }
 
@@ -3979,6 +4025,137 @@ function registerServeCommand(program) {
   });
 }
 
+// src/commands/domain-templates.ts
+import "commander";
+import dedent16 from "dedent";
+function registerDomainTemplateCommands(program) {
+  const templates = program.command("domain-templates").description("Browse and apply domain templates").addHelpText(
+    "after",
+    dedent16`
+
+        A domain template is an industry-specific starter pack of fact
+        definitions and sample rules. Applying one provisions a ready-to-use
+        policy group so you start from a working baseline instead of an
+        empty schema.
+
+        Commands:
+          list      List available domain templates
+          preview   Preview the facts and rules a template provisions
+          apply     Apply a template to the current tenant
+
+        Workflow: list → preview → apply
+        Currently available: ECOMMERCE  (FINTECH, SAAS — coming soon)
+      `
+  );
+  templates.command("list").description("List available domain templates").action(async () => {
+    try {
+      const globalOpts = program.opts();
+      const format = globalOpts.format ?? "json";
+      const data = await apiRequest("GET", "domain-templates", {
+        apiKey: globalOpts.apiKey,
+        baseUrl: globalOpts.baseUrl,
+        dryRun: globalOpts.dryRun,
+        verbose: globalOpts.verbose
+      });
+      if (format === "table") {
+        printTable(
+          ["Template", "Name", "Facts", "Rules", "Available"],
+          data.map((t) => [
+            t.template,
+            t.displayName,
+            String(t.factCount),
+            String(t.ruleCount),
+            t.isAvailable ? "\u2713" : "\u2013"
+          ]),
+          { truncate: 32 }
+        );
+      } else {
+        printJson(data);
+      }
+    } catch (error) {
+      printError(error);
+      process.exit(1);
+    }
+  });
+  templates.command("preview").description("Preview what a domain template provisions").requiredOption("--template <key>", "Domain template key (e.g. ECOMMERCE)").addHelpText(
+    "after",
+    dedent16`
+
+        Read-only dry run — shows the fact definitions and sample rules the
+        template will create. Nothing is provisioned.
+
+        Example:
+          $ lexq domain-templates preview --template ECOMMERCE
+      `
+  ).action(async (opts) => {
+    try {
+      const globalOpts = program.opts();
+      const data = await apiRequest(
+        "GET",
+        `domain-templates/${opts.template}/preview`,
+        {
+          apiKey: globalOpts.apiKey,
+          baseUrl: globalOpts.baseUrl,
+          dryRun: globalOpts.dryRun,
+          verbose: globalOpts.verbose
+        }
+      );
+      printJson(data);
+    } catch (error) {
+      printError(error);
+      process.exit(1);
+    }
+  });
+  templates.command("apply").description("Apply a domain template to the current tenant").requiredOption("--template <key>", "Domain template key (e.g. ECOMMERCE)").option("--name <n>", "Custom name for the policy group that gets created").option("--force", "Skip confirmation prompt").addHelpText(
+    "after",
+    dedent16`
+
+        Creates the template's fact definitions and a new DRAFT policy group
+        populated with its sample rules. Existing facts are skipped — apply is
+        additive and never overwrites your schema.
+
+        Run "preview" first to review what will be created.
+
+        Example:
+          $ lexq domain-templates apply --template ECOMMERCE
+          $ lexq domain-templates apply --template ECOMMERCE --name "My Store Policy"
+      `
+  ).action(async (opts) => {
+    try {
+      const globalOpts = program.opts();
+      if (!opts.force) {
+        const { createInterface: createInterface2 } = await import("readline/promises");
+        const rl = createInterface2({ input: process.stdin, output: process.stdout });
+        const answer = await rl.question(
+          `Apply domain template ${opts.template} to the current tenant? [y/N] `
+        );
+        rl.close();
+        if (answer.toLowerCase() !== "y") {
+          console.log("Cancelled.");
+          return;
+        }
+      }
+      const body = {};
+      if (opts.name) body.customName = opts.name;
+      const data = await apiRequest(
+        "POST",
+        `domain-templates/${opts.template}/apply`,
+        {
+          apiKey: globalOpts.apiKey,
+          baseUrl: globalOpts.baseUrl,
+          dryRun: globalOpts.dryRun,
+          verbose: globalOpts.verbose,
+          body
+        }
+      );
+      printJson(data);
+    } catch (error) {
+      printError(error);
+      process.exit(1);
+    }
+  });
+}
+
 // src/cli.ts
 var __dirname2 = dirname2(fileURLToPath2(import.meta.url));
 function getVersion2() {
@@ -4000,6 +4177,7 @@ function createCli() {
   registerVersionCommands(program);
   registerRuleCommands(program);
   registerFactCommands(program);
+  registerDomainTemplateCommands(program);
   registerDeployCommands(program);
   registerAnalyticsCommands(program);
   registerHistoryCommands(program);

package/dist/mcp/register.d.ts

@@ -27,7 +27,7 @@ type CallApi = (method: string, path: string, opts?: {
 declare function paginationParams(page?: number, size?: number): Record<string, string>;
 
 /**
- * Registers all 63 MCP tools on the given server.
+ * Registers all 66 MCP tools on the given server.
  *
  * @param server - McpServer instance
  * @param callApi - API caller function (config-based for CLI, Bearer-based for HTTP)

package/dist/mcp/register.js

@@ -1109,6 +1109,51 @@ function registerWebhookSubscriptionTools(server, callApi) {
   );
 }
 
+// src/mcp/tools/domain-templates.ts
+import { z as z11 } from "zod";
+function registerDomainTemplateTools(server, callApi) {
+  server.registerTool(
+    "lexq_domain_templates_list",
+    {
+      title: "List Domain Templates",
+      description: "List all domain templates. A domain template is a curated, industry-specific starter pack of fact definitions and sample rules (e.g. ECOMMERCE). Each entry reports its key, status (ACTIVE or COMING_SOON), and a summary of what it provisions. Call this before preview or apply to discover which templates can currently be applied.",
+      inputSchema: {}
+    },
+    async () => callApi("GET", "domain-templates")
+  );
+  server.registerTool(
+    "lexq_domain_templates_preview",
+    {
+      title: "Preview Domain Template",
+      description: "Preview exactly what a domain template will provision before applying it: the fact definitions it registers, the sample rules it creates, and an apply plan. This is a read-only dry run \u2014 nothing is created. Only ACTIVE templates can be previewed.",
+      inputSchema: {
+        template: z11.string().describe(
+          "Domain template key (e.g. ECOMMERCE). Use lexq_domain_templates_list to see available keys \u2014 currently only ECOMMERCE is ACTIVE."
+        )
+      }
+    },
+    async ({ template }) => callApi("GET", `domain-templates/${template}/preview`)
+  );
+  server.registerTool(
+    "lexq_domain_templates_apply",
+    {
+      title: "Apply Domain Template",
+      description: "Apply a domain template to the current tenant. Creates the template's fact definitions and a new policy group pre-populated with its sample rules as a DRAFT version. Existing facts are skipped \u2014 apply is additive and never overwrites existing schema. Run lexq_domain_templates_preview first to review what will be created. Only ACTIVE templates can be applied.",
+      inputSchema: {
+        template: z11.string().describe("Domain template key to apply (e.g. ECOMMERCE)."),
+        customName: z11.string().optional().describe(
+          "Optional custom name for the policy group that gets created. If omitted, the template's default name is used."
+        )
+      }
+    },
+    async ({ template, customName }) => {
+      const body = {};
+      if (customName !== void 0) body.customName = customName;
+      return callApi("POST", `domain-templates/${template}/apply`, { body });
+    }
+  );
+}
+
 // src/mcp/register.ts
 function registerAllTools(server, callApi) {
   registerStatusTools(server, callApi);
@@ -1121,6 +1166,7 @@ function registerAllTools(server, callApi) {
   registerHistoryTools(server, callApi);
   registerIntegrationTools(server, callApi);
   registerLogTools(server, callApi);
+  registerDomainTemplateTools(server, callApi);
   registerWebhookSubscriptionTools(server, callApi);
 }
 export {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@lexq/cli",
-  "version": "0.1.23",
+  "version": "0.1.26",
   "description": "LexQ CLI — manage policies, simulate rules, and deploy from the terminal. Built for humans and AI agents.",
   "type": "module",
   "bin": {
@@ -23,6 +23,14 @@
   "publishConfig": {
     "access": "public"
   },
+  "scripts": {
+    "dev": "tsup --watch",
+    "build": "tsup",
+    "lint": "eslint src/",
+    "typecheck": "tsc --noEmit",
+    "start": "node dist/index.js",
+    "prepublishOnly": "pnpm build"
+  },
   "keywords": [
     "lexq",
     "rule-engine",
@@ -43,6 +51,7 @@
   "engines": {
     "node": ">=18.0.0"
   },
+  "packageManager": "pnpm@10.28.0",
   "dependencies": {
     "@modelcontextprotocol/sdk": "^1.28.0",
     "cli-table3": "^0.6.5",
@@ -60,12 +69,5 @@
     "tsup": "^8.5.1",
     "typescript": "^5.7.0",
     "typescript-eslint": "^8.24.0"
-  },
-  "scripts": {
-    "dev": "tsup --watch",
-    "build": "tsup",
-    "lint": "eslint src/",
-    "typecheck": "tsc --noEmit",
-    "start": "node dist/index.js"
   }
-}
+}