@lexq/cli 0.1.0

package/dist/index.js

@@ -0,0 +1,1850 @@
+#!/usr/bin/env node
+
+// src/cli.ts
+import { Command } from "commander";
+import { readFileSync as readFileSync3 } from "fs";
+import { fileURLToPath } from "url";
+import { dirname, join as join2 } from "path";
+
+// src/commands/auth.ts
+import "commander";
+import { createInterface } from "readline/promises";
+import { stdin, stdout } from "process";
+
+// src/lib/config.ts
+import { existsSync, mkdirSync, readFileSync, writeFileSync, unlinkSync } from "fs";
+import { homedir } from "os";
+import { join } from "path";
+var CONFIG_DIR = join(homedir(), ".lexq");
+var CONFIG_FILE = join(CONFIG_DIR, "config.json");
+var DEFAULT_CONFIG = {
+  baseUrl: "https://api.lexq.io/api/v1/partners",
+  format: "json"
+};
+function loadConfig() {
+  if (!existsSync(CONFIG_FILE)) return { ...DEFAULT_CONFIG };
+  try {
+    const raw = readFileSync(CONFIG_FILE, "utf-8");
+    return { ...DEFAULT_CONFIG, ...JSON.parse(raw) };
+  } catch {
+    return { ...DEFAULT_CONFIG };
+  }
+}
+function saveConfig(config) {
+  if (!existsSync(CONFIG_DIR)) {
+    mkdirSync(CONFIG_DIR, { recursive: true });
+  }
+  const current = loadConfig();
+  const merged = { ...current, ...config };
+  writeFileSync(CONFIG_FILE, JSON.stringify(merged, null, 2), "utf-8");
+}
+function deleteConfig() {
+  if (existsSync(CONFIG_FILE)) {
+    unlinkSync(CONFIG_FILE);
+  }
+}
+function getConfigPath() {
+  return CONFIG_FILE;
+}
+
+// src/lib/api-client.ts
+var ApiError = class extends Error {
+  constructor(statusCode, errorCode, message) {
+    super(message);
+    this.statusCode = statusCode;
+    this.errorCode = errorCode;
+    this.name = "ApiError";
+  }
+};
+async function apiRequest(method, path, options = {}) {
+  const config = loadConfig();
+  const baseUrl = options.baseUrl ?? config.baseUrl;
+  const apiKey = options.apiKey ?? config.apiKey;
+  if (!apiKey) {
+    throw new ApiError(401, "AUTH", 'Not authenticated. Run "lexq auth login" first.');
+  }
+  const url = new URL(path, baseUrl.endsWith("/") ? baseUrl : baseUrl + "/");
+  if (options.params) {
+    for (const [key, value] of Object.entries(options.params)) {
+      if (value !== void 0 && value !== "") {
+        url.searchParams.set(key, value);
+      }
+    }
+  }
+  const headers = {
+    "X-API-KEY": apiKey,
+    "Accept": "application/json"
+  };
+  if (options.body) {
+    headers["Content-Type"] = "application/json";
+  }
+  if (options.dryRun) {
+    const masked = apiKey.length > 8 ? apiKey.substring(0, 4) + "****" + apiKey.substring(apiKey.length - 4) : "****";
+    console.log(`${method} ${url.toString()}`);
+    console.log("Headers:");
+    console.log(`  X-API-KEY: ${masked}`);
+    console.log(`  Content-Type: application/json`);
+    if (options.body) {
+      console.log("Body:");
+      console.log(`  ${JSON.stringify(options.body, null, 2)}`);
+    }
+    console.log("\n(Use without --dry-run to execute)");
+    process.exit(0);
+  }
+  if (options.verbose) {
+    console.error(`\u2192 ${method} ${url.toString()}`);
+  }
+  const startTime = Date.now();
+  const response = await fetch(url.toString(), {
+    method,
+    headers,
+    body: options.body ? JSON.stringify(options.body) : void 0
+  });
+  if (options.verbose) {
+    console.error(`\u2190 ${response.status} ${response.statusText} (${Date.now() - startTime}ms)`);
+  }
+  const contentType = response.headers.get("content-type") ?? "";
+  if (contentType.includes("text/csv") || contentType.includes("application/octet-stream")) {
+    return response;
+  }
+  if (response.status === 204 || contentType === "") {
+    return void 0;
+  }
+  const json = await response.json();
+  if (!response.ok || json.result !== "SUCCESS") {
+    throw new ApiError(
+      response.status,
+      json.errorCode,
+      json.message ?? `Request failed with status ${response.status}`
+    );
+  }
+  return json.data;
+}
+
+// src/lib/output.ts
+import Table from "cli-table3";
+function printJson(data) {
+  console.log(JSON.stringify(data, null, 2));
+}
+function printTable(headers, rows, options) {
+  const table = new Table({
+    head: headers,
+    style: { head: ["cyan"] },
+    wordWrap: true
+  });
+  for (const row of rows) {
+    if (options?.truncate) {
+      table.push(
+        row.map(
+          (cell) => cell.length > options.truncate ? cell.substring(0, options.truncate) + "\u2026" : cell
+        )
+      );
+    } else {
+      table.push(row);
+    }
+  }
+  console.log(table.toString());
+}
+function printError(error) {
+  if (error instanceof Error && "errorCode" in error) {
+    const apiErr = error;
+    const output = {
+      error: apiErr.errorCode ?? "UNKNOWN",
+      message: apiErr.message,
+      status: apiErr.statusCode
+    };
+    console.error(JSON.stringify(output, null, 2));
+  } else if (error instanceof Error) {
+    console.error(JSON.stringify({ error: "CLI_ERROR", message: error.message }, null, 2));
+  } else {
+    console.error(JSON.stringify({ error: "UNKNOWN", message: String(error) }, null, 2));
+  }
+}
+
+// src/commands/auth.ts
+function registerAuthCommands(program) {
+  const auth = program.command("auth").description("Manage authentication");
+  auth.command("login").description("Authenticate with your LexQ API key").action(async () => {
+    try {
+      const rl = createInterface({ input: stdin, output: stdout });
+      const apiKey = await rl.question("Enter your API Key: ");
+      rl.close();
+      if (!apiKey.trim()) {
+        console.error("API key cannot be empty.");
+        process.exit(1);
+      }
+      saveConfig({ apiKey: apiKey.trim() });
+      console.log(`\u2713 API key saved to ${getConfigPath()}`);
+      console.log('  Run "lexq auth whoami" to verify.');
+    } catch (error) {
+      printError(error);
+      process.exit(1);
+    }
+  });
+  auth.command("logout").description("Remove stored credentials").action(() => {
+    deleteConfig();
+    console.log("\u2713 Credentials removed.");
+  });
+  auth.command("whoami").description("Show current authentication info").action(async () => {
+    try {
+      const config = loadConfig();
+      if (!config.apiKey) {
+        console.error('Not authenticated. Run "lexq auth login" first.');
+        process.exit(1);
+      }
+      const info = await apiRequest(
+        "GET",
+        "whoami",
+        { apiKey: config.apiKey, baseUrl: config.baseUrl }
+      );
+      const masked = config.apiKey.length > 8 ? config.apiKey.substring(0, 4) + "****" + config.apiKey.substring(config.apiKey.length - 4) : "****";
+      printJson({
+        ...info,
+        apiKey: masked,
+        baseUrl: config.baseUrl
+      });
+    } catch (error) {
+      printError(error);
+      process.exit(1);
+    }
+  });
+}
+
+// src/commands/status.ts
+import "commander";
+function registerStatusCommand(program) {
+  program.command("status").description("Check LexQ API server status").action(async () => {
+    const config = loadConfig();
+    const baseUrl = config.baseUrl.replace(/\/v1\/partners\/?$/, "");
+    try {
+      const start = Date.now();
+      const response = await fetch(`${baseUrl}/health`);
+      const latency = Date.now() - start;
+      printJson({
+        status: response.ok ? "ok" : "degraded",
+        httpStatus: response.status,
+        latencyMs: latency,
+        endpoint: `${baseUrl}/health`
+      });
+    } catch {
+      printError(new Error(`Cannot reach LexQ API at ${baseUrl}/health`));
+      process.exit(1);
+    }
+  });
+}
+
+// src/commands/groups.ts
+import "commander";
+function registerGroupCommands(program) {
+  const groups = program.command("groups").description("Manage policy groups");
+  groups.command("list").description("List all policy groups").option("--page <number>", "Page number", "0").option("--size <number>", "Page size", "20").action(async (opts) => {
+    try {
+      const globalOpts = program.opts();
+      const format = globalOpts.format ?? "json";
+      const data = await apiRequest(
+        "GET",
+        "policy-groups",
+        {
+          apiKey: globalOpts.apiKey,
+          baseUrl: globalOpts.baseUrl,
+          dryRun: globalOpts.dryRun,
+          verbose: globalOpts.verbose,
+          params: { page: opts.page, size: opts.size }
+        }
+      );
+      if (format === "table") {
+        printTable(
+          ["ID", "Name", "Status", "Priority", "Version", "Updated"],
+          data.content.map((g) => [
+            g.id,
+            g.name,
+            g.status,
+            String(g.priority),
+            g.currentVersionName ?? "\u2013",
+            g.updatedAt.substring(0, 10)
+          ]),
+          { truncate: 24 }
+        );
+        console.log(`
+${data.totalElements} total \xB7 page ${data.pageNo + 1}/${data.totalPages}`);
+      } else {
+        printJson(data);
+      }
+    } catch (error) {
+      printError(error);
+      process.exit(1);
+    }
+  });
+  groups.command("get").description("Get a policy group by ID").requiredOption("--id <groupId>", "Policy group ID").action(async (opts) => {
+    try {
+      const globalOpts = program.opts();
+      const data = await apiRequest(
+        "GET",
+        `policy-groups/${opts.id}`,
+        {
+          apiKey: globalOpts.apiKey,
+          baseUrl: globalOpts.baseUrl,
+          dryRun: globalOpts.dryRun,
+          verbose: globalOpts.verbose
+        }
+      );
+      printJson(data);
+    } catch (error) {
+      printError(error);
+      process.exit(1);
+    }
+  });
+  groups.command("create").description("Create a new policy group").requiredOption("--json <body>", "Request body as JSON string").action(async (opts) => {
+    try {
+      const globalOpts = program.opts();
+      const body = JSON.parse(opts.json);
+      const data = await apiRequest(
+        "POST",
+        "policy-groups",
+        {
+          apiKey: globalOpts.apiKey,
+          baseUrl: globalOpts.baseUrl,
+          dryRun: globalOpts.dryRun,
+          verbose: globalOpts.verbose,
+          body
+        }
+      );
+      printJson(data);
+    } catch (error) {
+      printError(error);
+      process.exit(1);
+    }
+  });
+  groups.command("update").description("Update a policy group").requiredOption("--id <groupId>", "Policy group ID").requiredOption("--json <body>", "Request body as JSON string").action(async (opts) => {
+    try {
+      const globalOpts = program.opts();
+      const body = JSON.parse(opts.json);
+      const data = await apiRequest(
+        "PUT",
+        `policy-groups/${opts.id}`,
+        {
+          apiKey: globalOpts.apiKey,
+          baseUrl: globalOpts.baseUrl,
+          dryRun: globalOpts.dryRun,
+          verbose: globalOpts.verbose,
+          body
+        }
+      );
+      printJson(data);
+    } catch (error) {
+      printError(error);
+      process.exit(1);
+    }
+  });
+  groups.command("delete").description("Delete a policy group").requiredOption("--id <groupId>", "Policy group ID").option("--force", "Skip confirmation prompt").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(`Delete group ${opts.id}? [y/N] `);
+        rl.close();
+        if (answer.toLowerCase() !== "y") {
+          console.log("Cancelled.");
+          return;
+        }
+      }
+      await apiRequest(
+        "DELETE",
+        `policy-groups/${opts.id}`,
+        {
+          apiKey: globalOpts.apiKey,
+          baseUrl: globalOpts.baseUrl,
+          dryRun: globalOpts.dryRun,
+          verbose: globalOpts.verbose
+        }
+      );
+      console.log(`\u2713 Group ${opts.id} deleted.`);
+    } catch (error) {
+      printError(error);
+      process.exit(1);
+    }
+  });
+  const abTest = groups.command("ab-test").description("A/B test management");
+  abTest.command("start").description("Start an A/B test").requiredOption("--group-id <groupId>", "Policy group ID").requiredOption("--version-id <versionId>", "Challenger version ID").requiredOption("--traffic-rate <rate>", "Traffic rate for challenger (1-99)").action(async (opts) => {
+    try {
+      const globalOpts = program.opts();
+      const body = {
+        testVersionId: opts.versionId,
+        trafficRate: Number(opts.trafficRate)
+      };
+      const data = await apiRequest(
+        "POST",
+        `policy-groups/${opts.groupId}/ab-test`,
+        {
+          apiKey: globalOpts.apiKey,
+          baseUrl: globalOpts.baseUrl,
+          dryRun: globalOpts.dryRun,
+          verbose: globalOpts.verbose,
+          body
+        }
+      );
+      printJson(data);
+    } catch (error) {
+      printError(error);
+      process.exit(1);
+    }
+  });
+  abTest.command("stop").description("Stop an A/B test").requiredOption("--group-id <groupId>", "Policy group ID").option("--force", "Skip confirmation prompt").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(`Stop A/B test for group ${opts.groupId}? [y/N] `);
+        rl.close();
+        if (answer.toLowerCase() !== "y") {
+          console.log("Cancelled.");
+          return;
+        }
+      }
+      const data = await apiRequest(
+        "DELETE",
+        `policy-groups/${opts.groupId}/ab-test`,
+        {
+          apiKey: globalOpts.apiKey,
+          baseUrl: globalOpts.baseUrl,
+          dryRun: globalOpts.dryRun,
+          verbose: globalOpts.verbose
+        }
+      );
+      printJson(data);
+    } catch (error) {
+      printError(error);
+      process.exit(1);
+    }
+  });
+  abTest.command("adjust").description("Adjust A/B test traffic rate").requiredOption("--group-id <groupId>", "Policy group ID").requiredOption("--traffic-rate <rate>", "New traffic rate (1-99)").action(async (opts) => {
+    try {
+      const globalOpts = program.opts();
+      const body = {
+        trafficRate: Number(opts.trafficRate)
+      };
+      const data = await apiRequest(
+        "PATCH",
+        `policy-groups/${opts.groupId}/ab-test/traffic-rate`,
+        {
+          apiKey: globalOpts.apiKey,
+          baseUrl: globalOpts.baseUrl,
+          dryRun: globalOpts.dryRun,
+          verbose: globalOpts.verbose,
+          body
+        }
+      );
+      printJson(data);
+    } catch (error) {
+      printError(error);
+      process.exit(1);
+    }
+  });
+}
+
+// src/commands/versions.ts
+import "commander";
+function registerVersionCommands(program) {
+  const versions = program.command("versions").description("Manage policy versions");
+  versions.command("list").description("List versions for a policy group").requiredOption("--group-id <groupId>", "Policy group ID").option("--page <number>", "Page number", "0").option("--size <number>", "Page size", "20").action(async (opts) => {
+    try {
+      const globalOpts = program.opts();
+      const format = globalOpts.format ?? "json";
+      const data = await apiRequest(
+        "GET",
+        `policy-groups/${opts.groupId}/versions`,
+        {
+          apiKey: globalOpts.apiKey,
+          baseUrl: globalOpts.baseUrl,
+          dryRun: globalOpts.dryRun,
+          verbose: globalOpts.verbose,
+          params: { page: opts.page, size: opts.size }
+        }
+      );
+      if (format === "table") {
+        printTable(
+          ["ID", "v#", "Status", "Commit", "Hash", "Created"],
+          data.content.map((v) => [
+            v.id,
+            `v${v.versionNo}`,
+            v.status,
+            v.commitMessage ?? "\u2013",
+            v.snapshotHash ? v.snapshotHash.substring(0, 8) : "\u2013",
+            v.createdAt.substring(0, 10)
+          ]),
+          { truncate: 24 }
+        );
+        console.log(`
+${data.totalElements} total \xB7 page ${data.pageNo + 1}/${data.totalPages}`);
+      } else {
+        printJson(data);
+      }
+    } catch (error) {
+      printError(error);
+      process.exit(1);
+    }
+  });
+  versions.command("get").description("Get a policy version by ID").requiredOption("--group-id <groupId>", "Policy group ID").requiredOption("--id <versionId>", "Policy version ID").action(async (opts) => {
+    try {
+      const globalOpts = program.opts();
+      const data = await apiRequest(
+        "GET",
+        `policy-groups/${opts.groupId}/versions/${opts.id}`,
+        {
+          apiKey: globalOpts.apiKey,
+          baseUrl: globalOpts.baseUrl,
+          dryRun: globalOpts.dryRun,
+          verbose: globalOpts.verbose
+        }
+      );
+      printJson(data);
+    } catch (error) {
+      printError(error);
+      process.exit(1);
+    }
+  });
+  versions.command("create").description("Create a new draft version").requiredOption("--group-id <groupId>", "Policy group ID").option("--commit-message <message>", "Commit message").option("--effective-from <date>", "Effective from (ISO datetime)").option("--effective-to <date>", "Effective to (ISO datetime)").option("--json <body>", "Full request body as JSON (overrides other options)").action(async (opts) => {
+    try {
+      const globalOpts = program.opts();
+      const body = opts.json ? JSON.parse(opts.json) : buildCreateBody(opts);
+      const data = await apiRequest(
+        "POST",
+        `policy-groups/${opts.groupId}/versions`,
+        {
+          apiKey: globalOpts.apiKey,
+          baseUrl: globalOpts.baseUrl,
+          dryRun: globalOpts.dryRun,
+          verbose: globalOpts.verbose,
+          body
+        }
+      );
+      printJson(data);
+    } catch (error) {
+      printError(error);
+      process.exit(1);
+    }
+  });
+  versions.command("update").description("Update a draft version metadata").requiredOption("--group-id <groupId>", "Policy group ID").requiredOption("--id <versionId>", "Policy version ID").option("--commit-message <message>", "Commit message").option("--effective-from <date>", "Effective from (ISO datetime)").option("--effective-to <date>", "Effective to (ISO datetime)").option("--json <body>", "Full request body as JSON (overrides other options)").action(async (opts) => {
+    try {
+      const globalOpts = program.opts();
+      const body = opts.json ? JSON.parse(opts.json) : buildUpdateBody(opts);
+      const data = await apiRequest(
+        "PUT",
+        `policy-groups/${opts.groupId}/versions/${opts.id}`,
+        {
+          apiKey: globalOpts.apiKey,
+          baseUrl: globalOpts.baseUrl,
+          dryRun: globalOpts.dryRun,
+          verbose: globalOpts.verbose,
+          body
+        }
+      );
+      printJson(data);
+    } catch (error) {
+      printError(error);
+      process.exit(1);
+    }
+  });
+  versions.command("delete").description("Delete a policy version").requiredOption("--group-id <groupId>", "Policy group ID").requiredOption("--id <versionId>", "Policy version ID").option("--force", "Skip confirmation prompt").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(`Delete version ${opts.id}? [y/N] `);
+        rl.close();
+        if (answer.toLowerCase() !== "y") {
+          console.log("Cancelled.");
+          return;
+        }
+      }
+      await apiRequest(
+        "DELETE",
+        `policy-groups/${opts.groupId}/versions/${opts.id}`,
+        {
+          apiKey: globalOpts.apiKey,
+          baseUrl: globalOpts.baseUrl,
+          dryRun: globalOpts.dryRun,
+          verbose: globalOpts.verbose
+        }
+      );
+      console.log(`\u2713 Version ${opts.id} deleted.`);
+    } catch (error) {
+      printError(error);
+      process.exit(1);
+    }
+  });
+  versions.command("clone").description("Clone (duplicate) a policy version").requiredOption("--group-id <groupId>", "Policy group ID").requiredOption("--id <versionId>", "Source version ID to clone").action(async (opts) => {
+    try {
+      const globalOpts = program.opts();
+      const data = await apiRequest(
+        "POST",
+        `policy-groups/${opts.groupId}/versions/${opts.id}/clone`,
+        {
+          apiKey: globalOpts.apiKey,
+          baseUrl: globalOpts.baseUrl,
+          dryRun: globalOpts.dryRun,
+          verbose: globalOpts.verbose
+        }
+      );
+      printJson(data);
+    } catch (error) {
+      printError(error);
+      process.exit(1);
+    }
+  });
+}
+function buildCreateBody(opts) {
+  const body = {};
+  if (opts.commitMessage) body.commitMessage = opts.commitMessage;
+  if (opts.effectiveFrom) body.effectiveFrom = opts.effectiveFrom;
+  if (opts.effectiveTo) body.effectiveTo = opts.effectiveTo;
+  return body;
+}
+function buildUpdateBody(opts) {
+  const body = {};
+  if (opts.commitMessage) body.commitMessage = opts.commitMessage;
+  if (opts.effectiveFrom) body.effectiveFrom = opts.effectiveFrom;
+  if (opts.effectiveTo) body.effectiveTo = opts.effectiveTo;
+  return body;
+}
+
+// src/commands/rules.ts
+import "commander";
+function registerRuleCommands(program) {
+  const rules = program.command("rules").description("Manage policy rules");
+  rules.command("list").description("List rules for a policy version").requiredOption("--group-id <groupId>", "Policy group ID").requiredOption("--version-id <versionId>", "Policy version ID").option("--page <number>", "Page number", "0").option("--size <number>", "Page size", "20").action(async (opts) => {
+    try {
+      const globalOpts = program.opts();
+      const format = globalOpts.format ?? "json";
+      const data = await apiRequest(
+        "GET",
+        `policy-groups/${opts.groupId}/versions/${opts.versionId}/rules`,
+        {
+          apiKey: globalOpts.apiKey,
+          baseUrl: globalOpts.baseUrl,
+          dryRun: globalOpts.dryRun,
+          verbose: globalOpts.verbose,
+          params: { page: opts.page, size: opts.size }
+        }
+      );
+      if (format === "table") {
+        printTable(
+          ["ID", "Name", "Priority", "Conditions", "Actions", "Enabled"],
+          data.content.map((r) => [
+            r.id,
+            r.name,
+            String(r.priority),
+            String(r.totalConditionCount),
+            String(r.totalActionCount),
+            r.isEnabled ? "\u2713" : "\u2717"
+          ]),
+          { truncate: 24 }
+        );
+        console.log(`
+${data.totalElements} total \xB7 page ${data.pageNo + 1}/${data.totalPages}`);
+      } else {
+        printJson(data);
+      }
+    } catch (error) {
+      printError(error);
+      process.exit(1);
+    }
+  });
+  rules.command("get").description("Get a rule by ID").requiredOption("--group-id <groupId>", "Policy group ID").requiredOption("--version-id <versionId>", "Policy version ID").requiredOption("--id <ruleId>", "Rule ID").action(async (opts) => {
+    try {
+      const globalOpts = program.opts();
+      const data = await apiRequest(
+        "GET",
+        `policy-groups/${opts.groupId}/versions/${opts.versionId}/rules/${opts.id}`,
+        {
+          apiKey: globalOpts.apiKey,
+          baseUrl: globalOpts.baseUrl,
+          dryRun: globalOpts.dryRun,
+          verbose: globalOpts.verbose
+        }
+      );
+      printJson(data);
+    } catch (error) {
+      printError(error);
+      process.exit(1);
+    }
+  });
+  rules.command("create").description("Create a new rule").requiredOption("--group-id <groupId>", "Policy group ID").requiredOption("--version-id <versionId>", "Policy version ID").requiredOption("--json <body>", "Request body as JSON string").action(async (opts) => {
+    try {
+      const globalOpts = program.opts();
+      const body = JSON.parse(opts.json);
+      const data = await apiRequest(
+        "POST",
+        `policy-groups/${opts.groupId}/versions/${opts.versionId}/rules`,
+        {
+          apiKey: globalOpts.apiKey,
+          baseUrl: globalOpts.baseUrl,
+          dryRun: globalOpts.dryRun,
+          verbose: globalOpts.verbose,
+          body
+        }
+      );
+      printJson(data);
+    } catch (error) {
+      printError(error);
+      process.exit(1);
+    }
+  });
+  rules.command("update").description("Update a rule").requiredOption("--group-id <groupId>", "Policy group ID").requiredOption("--version-id <versionId>", "Policy version ID").requiredOption("--id <ruleId>", "Rule ID").requiredOption("--json <body>", "Request body as JSON string").action(async (opts) => {
+    try {
+      const globalOpts = program.opts();
+      const body = JSON.parse(opts.json);
+      const data = await apiRequest(
+        "PUT",
+        `policy-groups/${opts.groupId}/versions/${opts.versionId}/rules/${opts.id}`,
+        {
+          apiKey: globalOpts.apiKey,
+          baseUrl: globalOpts.baseUrl,
+          dryRun: globalOpts.dryRun,
+          verbose: globalOpts.verbose,
+          body
+        }
+      );
+      printJson(data);
+    } catch (error) {
+      printError(error);
+      process.exit(1);
+    }
+  });
+  rules.command("delete").description("Delete a rule").requiredOption("--group-id <groupId>", "Policy group ID").requiredOption("--version-id <versionId>", "Policy version ID").requiredOption("--id <ruleId>", "Rule ID").option("--force", "Skip confirmation prompt").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(`Delete rule ${opts.id}? [y/N] `);
+        rl.close();
+        if (answer.toLowerCase() !== "y") {
+          console.log("Cancelled.");
+          return;
+        }
+      }
+      await apiRequest(
+        "DELETE",
+        `policy-groups/${opts.groupId}/versions/${opts.versionId}/rules/${opts.id}`,
+        {
+          apiKey: globalOpts.apiKey,
+          baseUrl: globalOpts.baseUrl,
+          dryRun: globalOpts.dryRun,
+          verbose: globalOpts.verbose
+        }
+      );
+      console.log(`\u2713 Rule ${opts.id} deleted.`);
+    } catch (error) {
+      printError(error);
+      process.exit(1);
+    }
+  });
+  rules.command("reorder").description("Reorder rules by priority (drag & drop equivalent)").requiredOption("--group-id <groupId>", "Policy group ID").requiredOption("--version-id <versionId>", "Policy version ID").requiredOption("--rule-ids <ids>", "Comma-separated rule IDs in desired order").action(async (opts) => {
+    try {
+      const globalOpts = program.opts();
+      const ruleIds = opts.ruleIds.split(",").map((id) => id.trim());
+      const body = {
+        rules: ruleIds.map((ruleId, index) => ({
+          ruleId,
+          priority: index
+        }))
+      };
+      await apiRequest(
+        "PATCH",
+        `policy-groups/${opts.groupId}/versions/${opts.versionId}/rules/reorder`,
+        {
+          apiKey: globalOpts.apiKey,
+          baseUrl: globalOpts.baseUrl,
+          dryRun: globalOpts.dryRun,
+          verbose: globalOpts.verbose,
+          body
+        }
+      );
+      console.log(`\u2713 ${ruleIds.length} rules reordered.`);
+    } catch (error) {
+      printError(error);
+      process.exit(1);
+    }
+  });
+  rules.command("toggle").description("Enable or disable a rule").requiredOption("--group-id <groupId>", "Policy group ID").requiredOption("--version-id <versionId>", "Policy version ID").requiredOption("--id <ruleId>", "Rule ID").requiredOption("--enabled <boolean>", "true or false").action(async (opts) => {
+    try {
+      const globalOpts = program.opts();
+      const isEnabled = opts.enabled === "true";
+      await apiRequest(
+        "PATCH",
+        `policy-groups/${opts.groupId}/versions/${opts.versionId}/rules/${opts.id}/enabled`,
+        {
+          apiKey: globalOpts.apiKey,
+          baseUrl: globalOpts.baseUrl,
+          dryRun: globalOpts.dryRun,
+          verbose: globalOpts.verbose,
+          body: { isEnabled }
+        }
+      );
+      console.log(`\u2713 Rule ${opts.id} ${isEnabled ? "enabled" : "disabled"}.`);
+    } catch (error) {
+      printError(error);
+      process.exit(1);
+    }
+  });
+}
+
+// src/commands/facts.ts
+import "commander";
+function registerFactCommands(program) {
+  const facts = program.command("facts").description("Manage fact definitions (schema)");
+  facts.command("list").description("List fact definitions").option("--keyword <keyword>", "Filter by keyword").option("--page <number>", "Page number", "0").option("--size <number>", "Page size", "20").action(async (opts) => {
+    try {
+      const globalOpts = program.opts();
+      const format = globalOpts.format ?? "json";
+      const params = {
+        page: opts.page,
+        size: opts.size
+      };
+      if (opts.keyword) params.keyword = opts.keyword;
+      const data = await apiRequest(
+        "GET",
+        "schema/facts",
+        {
+          apiKey: globalOpts.apiKey,
+          baseUrl: globalOpts.baseUrl,
+          dryRun: globalOpts.dryRun,
+          verbose: globalOpts.verbose,
+          params
+        }
+      );
+      if (format === "table") {
+        printTable(
+          ["ID", "Key", "Name", "Type", "System", "Required"],
+          data.content.map((f) => [
+            f.id,
+            f.key,
+            f.name,
+            f.type,
+            f.isSystem ? "\u2713" : "\u2013",
+            f.isRequired ? "\u2713" : "\u2013"
+          ]),
+          { truncate: 28 }
+        );
+        console.log(`
+${data.totalElements} total \xB7 page ${data.pageNo + 1}/${data.totalPages}`);
+      } else {
+        printJson(data);
+      }
+    } catch (error) {
+      printError(error);
+      process.exit(1);
+    }
+  });
+  facts.command("create").description("Create a new fact definition").option("--key <key>", "Fact key (lowercase, underscores)").option("--name <name>", "Display name").option("--type <type>", "Value type: STRING, NUMBER, BOOLEAN, LIST_STRING, LIST_NUMBER").option("--description <desc>", "Description").option("--required", "Mark as required", false).option("--json <body>", "Full request body as JSON (overrides other options)").action(async (opts) => {
+    try {
+      const globalOpts = program.opts();
+      const body = opts.json ? JSON.parse(opts.json) : buildCreateBody2(opts);
+      const data = await apiRequest(
+        "POST",
+        "schema/facts",
+        {
+          apiKey: globalOpts.apiKey,
+          baseUrl: globalOpts.baseUrl,
+          dryRun: globalOpts.dryRun,
+          verbose: globalOpts.verbose,
+          body
+        }
+      );
+      printJson(data);
+    } catch (error) {
+      printError(error);
+      process.exit(1);
+    }
+  });
+  facts.command("update").description("Update a fact definition").requiredOption("--id <factId>", "Fact definition ID").option("--name <name>", "Display name").option("--description <desc>", "Description").option("--required", "Mark as required").option("--no-required", "Mark as not required").option("--json <body>", "Full request body as JSON (overrides other options)").action(async (opts) => {
+    try {
+      const globalOpts = program.opts();
+      const body = opts.json ? JSON.parse(opts.json) : buildUpdateBody2(opts);
+      const data = await apiRequest(
+        "PUT",
+        `schema/facts/${opts.id}`,
+        {
+          apiKey: globalOpts.apiKey,
+          baseUrl: globalOpts.baseUrl,
+          dryRun: globalOpts.dryRun,
+          verbose: globalOpts.verbose,
+          body
+        }
+      );
+      printJson(data);
+    } catch (error) {
+      printError(error);
+      process.exit(1);
+    }
+  });
+  facts.command("delete").description("Delete a fact definition").requiredOption("--id <factId>", "Fact definition ID").option("--force", "Skip confirmation prompt").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(`Delete fact ${opts.id}? [y/N] `);
+        rl.close();
+        if (answer.toLowerCase() !== "y") {
+          console.log("Cancelled.");
+          return;
+        }
+      }
+      await apiRequest(
+        "DELETE",
+        `schema/facts/${opts.id}`,
+        {
+          apiKey: globalOpts.apiKey,
+          baseUrl: globalOpts.baseUrl,
+          dryRun: globalOpts.dryRun,
+          verbose: globalOpts.verbose
+        }
+      );
+      console.log(`\u2713 Fact ${opts.id} deleted.`);
+    } catch (error) {
+      printError(error);
+      process.exit(1);
+    }
+  });
+  facts.command("action-metadata").description("Get action runtime fact metadata").action(async () => {
+    try {
+      const globalOpts = program.opts();
+      const data = await apiRequest(
+        "GET",
+        "schema/action-metadata",
+        {
+          apiKey: globalOpts.apiKey,
+          baseUrl: globalOpts.baseUrl,
+          dryRun: globalOpts.dryRun,
+          verbose: globalOpts.verbose
+        }
+      );
+      printJson(data);
+    } catch (error) {
+      printError(error);
+      process.exit(1);
+    }
+  });
+}
+function buildCreateBody2(opts) {
+  if (!opts.key || !opts.name || !opts.type) {
+    throw new Error("--key, --name, and --type are required (or use --json).");
+  }
+  const body = {
+    key: opts.key,
+    name: opts.name,
+    type: opts.type,
+    isRequired: opts.required === true
+  };
+  if (opts.description) body.description = opts.description;
+  return body;
+}
+function buildUpdateBody2(opts) {
+  const body = {};
+  if (opts.name) body.name = opts.name;
+  if (opts.description !== void 0) body.description = opts.description;
+  if (typeof opts.required === "boolean") body.isRequired = opts.required;
+  return body;
+}
+
+// src/commands/deploy.ts
+import "commander";
+function registerDeployCommands(program) {
+  const deploy = program.command("deploy").description("Deployment lifecycle and history");
+  deploy.command("publish").description("Publish a DRAFT version (DRAFT \u2192 ACTIVE)").requiredOption("--group-id <groupId>", "Policy group ID").requiredOption("--version-id <versionId>", "Version ID to publish").option("--memo <memo>", "Deployment memo").action(async (opts) => {
+    try {
+      const globalOpts = program.opts();
+      await apiRequest(
+        "POST",
+        `policy-groups/${opts.groupId}/versions/${opts.versionId}/publish`,
+        {
+          apiKey: globalOpts.apiKey,
+          baseUrl: globalOpts.baseUrl,
+          dryRun: globalOpts.dryRun,
+          verbose: globalOpts.verbose,
+          body: { memo: opts.memo ?? "" }
+        }
+      );
+      console.log(`\u2713 Version ${opts.versionId} published.`);
+    } catch (error) {
+      printError(error);
+      process.exit(1);
+    }
+  });
+  deploy.command("live").description("Deploy an ACTIVE version to live traffic").requiredOption("--group-id <groupId>", "Policy group ID").requiredOption("--version-id <versionId>", "Version ID to deploy").option("--memo <memo>", "Deployment memo").action(async (opts) => {
+    try {
+      const globalOpts = program.opts();
+      await apiRequest(
+        "POST",
+        `policy-groups/${opts.groupId}/deploy`,
+        {
+          apiKey: globalOpts.apiKey,
+          baseUrl: globalOpts.baseUrl,
+          dryRun: globalOpts.dryRun,
+          verbose: globalOpts.verbose,
+          body: { versionId: opts.versionId, memo: opts.memo ?? "" }
+        }
+      );
+      console.log(`\u2713 Version ${opts.versionId} deployed to live.`);
+    } catch (error) {
+      printError(error);
+      process.exit(1);
+    }
+  });
+  deploy.command("rollback").description("Rollback to the previous deployed version").requiredOption("--group-id <groupId>", "Policy group ID").option("--memo <memo>", "Rollback reason").option("--force", "Skip confirmation prompt").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(`Rollback group ${opts.groupId}? [y/N] `);
+        rl.close();
+        if (answer.toLowerCase() !== "y") {
+          console.log("Cancelled.");
+          return;
+        }
+      }
+      await apiRequest(
+        "POST",
+        `policy-groups/${opts.groupId}/rollback`,
+        {
+          apiKey: globalOpts.apiKey,
+          baseUrl: globalOpts.baseUrl,
+          dryRun: globalOpts.dryRun,
+          verbose: globalOpts.verbose,
+          body: { memo: opts.memo ?? "" }
+        }
+      );
+      console.log(`\u2713 Group ${opts.groupId} rolled back.`);
+    } catch (error) {
+      printError(error);
+      process.exit(1);
+    }
+  });
+  deploy.command("undeploy").description("Remove the live version from a group").requiredOption("--group-id <groupId>", "Policy group ID").option("--memo <memo>", "Undeploy reason").option("--force", "Skip confirmation prompt").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(`Undeploy group ${opts.groupId}? [y/N] `);
+        rl.close();
+        if (answer.toLowerCase() !== "y") {
+          console.log("Cancelled.");
+          return;
+        }
+      }
+      await apiRequest(
+        "POST",
+        `policy-groups/${opts.groupId}/undeploy`,
+        {
+          apiKey: globalOpts.apiKey,
+          baseUrl: globalOpts.baseUrl,
+          dryRun: globalOpts.dryRun,
+          verbose: globalOpts.verbose,
+          body: { memo: opts.memo ?? "" }
+        }
+      );
+      console.log(`\u2713 Group ${opts.groupId} undeployed.`);
+    } catch (error) {
+      printError(error);
+      process.exit(1);
+    }
+  });
+  deploy.command("history").description("List deployment history").option("--group-id <groupId>", "Filter by policy group").option("--types <types>", "Filter by types (comma-separated: PUBLISH,DEPLOY,ROLLBACK,UNDEPLOY)").option("--start-date <date>", "Start date (yyyy-MM-dd)").option("--end-date <date>", "End date (yyyy-MM-dd)").option("--page <number>", "Page number", "0").option("--size <number>", "Page size", "20").action(async (opts) => {
+    try {
+      const globalOpts = program.opts();
+      const format = globalOpts.format ?? "json";
+      const params = {
+        page: opts.page,
+        size: opts.size
+      };
+      if (opts.groupId) params.groupId = opts.groupId;
+      if (opts.types) params.types = opts.types;
+      if (opts.startDate) params.startDate = opts.startDate;
+      if (opts.endDate) params.endDate = opts.endDate;
+      const data = await apiRequest(
+        "GET",
+        "deployments",
+        {
+          apiKey: globalOpts.apiKey,
+          baseUrl: globalOpts.baseUrl,
+          dryRun: globalOpts.dryRun,
+          verbose: globalOpts.verbose,
+          params
+        }
+      );
+      if (format === "table") {
+        printTable(
+          ["ID", "Type", "Group", "Version", "By", "At"],
+          data.content.map((d) => [
+            d.id.substring(0, 8),
+            d.deploymentType,
+            d.policyGroupName,
+            d.versionNo != null ? `v${d.versionNo}` : "\u2013",
+            d.deployedByName,
+            d.deployedAt.substring(0, 16)
+          ]),
+          { truncate: 20 }
+        );
+        console.log(`
+${data.totalElements} total \xB7 page ${data.pageNo + 1}/${data.totalPages}`);
+      } else {
+        printJson(data);
+      }
+    } catch (error) {
+      printError(error);
+      process.exit(1);
+    }
+  });
+  deploy.command("detail").description("Get deployment detail").requiredOption("--id <deploymentId>", "Deployment ID").action(async (opts) => {
+    try {
+      const globalOpts = program.opts();
+      const data = await apiRequest(
+        "GET",
+        `deployments/${opts.id}`,
+        {
+          apiKey: globalOpts.apiKey,
+          baseUrl: globalOpts.baseUrl,
+          dryRun: globalOpts.dryRun,
+          verbose: globalOpts.verbose
+        }
+      );
+      printJson(data);
+    } catch (error) {
+      printError(error);
+      process.exit(1);
+    }
+  });
+  deploy.command("overview").description("Show deployment status overview for all groups").action(async () => {
+    try {
+      const globalOpts = program.opts();
+      const format = globalOpts.format ?? "json";
+      const data = await apiRequest(
+        "GET",
+        "deployments/overview",
+        {
+          apiKey: globalOpts.apiKey,
+          baseUrl: globalOpts.baseUrl,
+          dryRun: globalOpts.dryRun,
+          verbose: globalOpts.verbose
+        }
+      );
+      if (format === "table") {
+        printTable(
+          ["Group", "Name", "Status", "Current Version", "Last Deploy"],
+          data.map((d) => [
+            d.groupId.substring(0, 8),
+            d.groupName,
+            d.groupStatus,
+            d.currentVersionName ?? "\u2013",
+            d.lastDeployedAt?.substring(0, 16) ?? "\u2013"
+          ])
+        );
+      } else {
+        printJson(data);
+      }
+    } catch (error) {
+      printError(error);
+      process.exit(1);
+    }
+  });
+  deploy.command("deployable").description("List deployable (ACTIVE) versions for a group").requiredOption("--group-id <groupId>", "Policy group ID").action(async (opts) => {
+    try {
+      const globalOpts = program.opts();
+      const data = await apiRequest(
+        "GET",
+        `deployments/groups/${opts.groupId}/deployable-versions`,
+        {
+          apiKey: globalOpts.apiKey,
+          baseUrl: globalOpts.baseUrl,
+          dryRun: globalOpts.dryRun,
+          verbose: globalOpts.verbose
+        }
+      );
+      printJson(data);
+    } catch (error) {
+      printError(error);
+      process.exit(1);
+    }
+  });
+  deploy.command("diff").description("Compare snapshot diff between two versions").requiredOption("--base <versionId>", "Base version ID").requiredOption("--target <versionId>", "Target version ID").action(async (opts) => {
+    try {
+      const globalOpts = program.opts();
+      const data = await apiRequest(
+        "GET",
+        "deployments/diff",
+        {
+          apiKey: globalOpts.apiKey,
+          baseUrl: globalOpts.baseUrl,
+          dryRun: globalOpts.dryRun,
+          verbose: globalOpts.verbose,
+          params: {
+            baseVersionId: opts.base,
+            targetVersionId: opts.target
+          }
+        }
+      );
+      printJson(data);
+    } catch (error) {
+      printError(error);
+      process.exit(1);
+    }
+  });
+}
+
+// src/commands/analytics.ts
+import { readFileSync as readFileSync2 } from "fs";
+import "commander";
+function registerAnalyticsCommands(program) {
+  const analytics = program.command("analytics").description("Dry run, simulation, and requirements");
+  analytics.command("dry-run").description("Execute a single dry run against a version").requiredOption("--version-id <versionId>", "Policy version ID").option("--json <body>", "Request body as JSON string").option("--file <path>", "Read request body from a JSON file").option("--debug", "Include debug traces", false).option("--mock", "Mock external calls", false).action(async (opts) => {
+    try {
+      const globalOpts = program.opts();
+      const body = resolveBody(opts);
+      if (!body.facts) {
+        throw new Error('Request body must include "facts". Use --json or --file.');
+      }
+      body.includeDebugInfo = opts.debug;
+      body.mockExternalCalls = opts.mock;
+      const data = await apiRequest(
+        "POST",
+        `analytics/dry-run/versions/${opts.versionId}`,
+        {
+          apiKey: globalOpts.apiKey,
+          baseUrl: globalOpts.baseUrl,
+          dryRun: globalOpts.dryRun,
+          verbose: globalOpts.verbose,
+          body
+        }
+      );
+      printJson(data);
+    } catch (error) {
+      printError(error);
+      process.exit(1);
+    }
+  });
+  analytics.command("dry-run-compare").description("Compare dry run results between two versions").option("--json <body>", "Request body as JSON string").option("--file <path>", "Read request body from a JSON file").action(async (opts) => {
+    try {
+      const globalOpts = program.opts();
+      const body = resolveBody(opts);
+      if (!body.facts || !body.versionIdA || !body.versionIdB) {
+        throw new Error('Request body must include "facts", "versionIdA", "versionIdB". Use --json or --file.');
+      }
+      const data = await apiRequest(
+        "POST",
+        "analytics/dry-run/compare",
+        {
+          apiKey: globalOpts.apiKey,
+          baseUrl: globalOpts.baseUrl,
+          dryRun: globalOpts.dryRun,
+          verbose: globalOpts.verbose,
+          body
+        }
+      );
+      printJson(data);
+    } catch (error) {
+      printError(error);
+      process.exit(1);
+    }
+  });
+  analytics.command("requirements").description("Analyze required input facts for a version").requiredOption("--group-id <groupId>", "Policy group ID").requiredOption("--version-id <versionId>", "Policy version ID").action(async (opts) => {
+    try {
+      const globalOpts = program.opts();
+      const format = globalOpts.format ?? "json";
+      const data = await apiRequest(
+        "GET",
+        `analytics/groups/${opts.groupId}/versions/${opts.versionId}/requirements`,
+        {
+          apiKey: globalOpts.apiKey,
+          baseUrl: globalOpts.baseUrl,
+          dryRun: globalOpts.dryRun,
+          verbose: globalOpts.verbose
+        }
+      );
+      if (format === "table") {
+        printTable(
+          ["Key", "Type", "Name", "Required", "Used By"],
+          data.requiredFacts.map((f) => [
+            f.key,
+            f.type ?? "\u2013",
+            f.displayName ?? "\u2013",
+            f.required ? "\u2713" : "\u2013",
+            f.usedBy.join(", ") || "\u2013"
+          ])
+        );
+        console.log("\nExample request:");
+        console.log(JSON.stringify(data.exampleRequest, null, 2));
+      } else {
+        printJson(data);
+      }
+    } catch (error) {
+      printError(error);
+      process.exit(1);
+    }
+  });
+  const sim = analytics.command("simulation").description("Manage batch simulations");
+  sim.command("start").description("Start a new batch simulation").requiredOption("--json <body>", "Simulation request body as JSON").option("--file <path>", "Read request body from a JSON file").action(async (opts) => {
+    try {
+      const globalOpts = program.opts();
+      const body = resolveBody(opts);
+      const data = await apiRequest(
+        "POST",
+        "analytics/simulations",
+        {
+          apiKey: globalOpts.apiKey,
+          baseUrl: globalOpts.baseUrl,
+          dryRun: globalOpts.dryRun,
+          verbose: globalOpts.verbose,
+          body
+        }
+      );
+      console.log(`\u2713 Simulation started: ${data.simulationId} (${data.status})`);
+      printJson(data);
+    } catch (error) {
+      printError(error);
+      process.exit(1);
+    }
+  });
+  sim.command("status").description("Get simulation status and results").requiredOption("--id <simulationId>", "Simulation ID").action(async (opts) => {
+    try {
+      const globalOpts = program.opts();
+      const data = await apiRequest(
+        "GET",
+        `analytics/simulations/${opts.id}`,
+        {
+          apiKey: globalOpts.apiKey,
+          baseUrl: globalOpts.baseUrl,
+          dryRun: globalOpts.dryRun,
+          verbose: globalOpts.verbose
+        }
+      );
+      printJson(data);
+    } catch (error) {
+      printError(error);
+      process.exit(1);
+    }
+  });
+  sim.command("list").description("List simulation history").option("--status <status>", "Filter by status (PENDING, RUNNING, COMPLETED, FAILED, CANCELLED)").option("--from <date>", "Start date (yyyy-MM-dd)").option("--to <date>", "End date (yyyy-MM-dd)").option("--page <number>", "Page number", "0").option("--size <number>", "Page size", "20").action(async (opts) => {
+    try {
+      const globalOpts = program.opts();
+      const format = globalOpts.format ?? "json";
+      const params = {
+        page: opts.page,
+        size: opts.size
+      };
+      if (opts.status) params.status = opts.status;
+      if (opts.from) params.from = opts.from;
+      if (opts.to) params.to = opts.to;
+      const data = await apiRequest(
+        "GET",
+        "analytics/simulations",
+        {
+          apiKey: globalOpts.apiKey,
+          baseUrl: globalOpts.baseUrl,
+          dryRun: globalOpts.dryRun,
+          verbose: globalOpts.verbose,
+          params
+        }
+      );
+      if (format === "table") {
+        printTable(
+          ["ID", "Group", "Target", "Status", "Match", "Records", "Created"],
+          data.content.map((s) => [
+            s.simulationId.substring(0, 8),
+            s.policyGroupName,
+            s.targetVersionName ?? "\u2013",
+            s.status,
+            `${(s.matchRate * 100).toFixed(1)}%`,
+            String(s.totalRecords),
+            s.createdAt.substring(0, 16)
+          ]),
+          { truncate: 20 }
+        );
+        console.log(`
+${data.totalElements} total \xB7 page ${data.pageNo + 1}/${data.totalPages}`);
+      } else {
+        printJson(data);
+      }
+    } catch (error) {
+      printError(error);
+      process.exit(1);
+    }
+  });
+  sim.command("cancel").description("Cancel a running simulation").requiredOption("--id <simulationId>", "Simulation ID").option("--force", "Skip confirmation prompt").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(`Cancel simulation ${opts.id}? [y/N] `);
+        rl.close();
+        if (answer.toLowerCase() !== "y") {
+          console.log("Cancelled.");
+          return;
+        }
+      }
+      await apiRequest(
+        "DELETE",
+        `analytics/simulations/${opts.id}`,
+        {
+          apiKey: globalOpts.apiKey,
+          baseUrl: globalOpts.baseUrl,
+          dryRun: globalOpts.dryRun,
+          verbose: globalOpts.verbose
+        }
+      );
+      console.log(`\u2713 Simulation ${opts.id} cancelled.`);
+    } catch (error) {
+      printError(error);
+      process.exit(1);
+    }
+  });
+  sim.command("export").description("Export simulation results").requiredOption("--id <simulationId>", "Simulation ID").option("--format <fmt>", "Export format: csv or json", "json").option("--output <path>", "Output file path").action(async (opts) => {
+    try {
+      const globalOpts = program.opts();
+      const exportFormat = opts.format === "csv" ? "csv" : "json";
+      const response = await apiRequest(
+        "GET",
+        `analytics/simulations/${opts.id}/export`,
+        {
+          apiKey: globalOpts.apiKey,
+          baseUrl: globalOpts.baseUrl,
+          dryRun: globalOpts.dryRun,
+          verbose: globalOpts.verbose,
+          params: { format: exportFormat }
+        }
+      );
+      if (opts.output) {
+        const { writeFileSync: writeFileSync2 } = await import("fs");
+        const text = typeof response === "string" ? response : JSON.stringify(response, null, 2);
+        writeFileSync2(opts.output, text, "utf-8");
+        console.log(`\u2713 Exported to ${opts.output}`);
+      } else {
+        printJson(response);
+      }
+    } catch (error) {
+      printError(error);
+      process.exit(1);
+    }
+  });
+}
+function resolveBody(opts) {
+  if (opts.file) {
+    const raw = readFileSync2(opts.file, "utf-8");
+    return JSON.parse(raw);
+  }
+  if (opts.json) {
+    return JSON.parse(opts.json);
+  }
+  return {};
+}
+
+// src/commands/history.ts
+import "commander";
+function registerHistoryCommands(program) {
+  const history = program.command("history").description("Execution history");
+  history.command("list").description("List execution history").option("--trace-id <traceId>", "Filter by trace ID").option("--group-id <groupId>", "Filter by policy group").option("--version-id <versionId>", "Filter by version").option("--status <status>", "Filter by status (SUCCESS, NO_MATCH, ERROR, TIMEOUT)").option("--start-date <date>", "Start date (yyyy-MM-dd)").option("--end-date <date>", "End date (yyyy-MM-dd)").option("--page <number>", "Page number", "0").option("--size <number>", "Page size", "20").action(async (opts) => {
+    try {
+      const globalOpts = program.opts();
+      const format = globalOpts.format ?? "json";
+      const params = {
+        page: opts.page,
+        size: opts.size
+      };
+      if (opts.traceId) params.traceId = opts.traceId;
+      if (opts.groupId) params.policyGroupId = opts.groupId;
+      if (opts.versionId) params.versionId = opts.versionId;
+      if (opts.status) params.status = opts.status;
+      if (opts.startDate) params.startDate = opts.startDate;
+      if (opts.endDate) params.endDate = opts.endDate;
+      const data = await apiRequest(
+        "GET",
+        "execution/history",
+        {
+          apiKey: globalOpts.apiKey,
+          baseUrl: globalOpts.baseUrl,
+          dryRun: globalOpts.dryRun,
+          verbose: globalOpts.verbose,
+          params
+        }
+      );
+      if (format === "table") {
+        printTable(
+          ["Trace", "Group", "Version", "Status", "Matched", "Latency", "At"],
+          data.content.map((h) => [
+            h.traceId.substring(0, 12),
+            h.policyGroupName ?? "\u2013",
+            h.policyVersionNo != null ? `v${h.policyVersionNo}` : "\u2013",
+            h.status,
+            h.isMatched ? "\u2713" : "\u2717",
+            `${h.latencyMs}ms`,
+            h.createdAt.substring(0, 16)
+          ]),
+          { truncate: 20 }
+        );
+        console.log(`
+${data.totalElements} total \xB7 page ${data.pageNo + 1}/${data.totalPages}`);
+      } else {
+        printJson(data);
+      }
+    } catch (error) {
+      printError(error);
+      process.exit(1);
+    }
+  });
+  history.command("get").description("Get execution detail").requiredOption("--id <executionId>", "Execution history ID").action(async (opts) => {
+    try {
+      const globalOpts = program.opts();
+      const data = await apiRequest(
+        "GET",
+        `execution/history/${opts.id}`,
+        {
+          apiKey: globalOpts.apiKey,
+          baseUrl: globalOpts.baseUrl,
+          dryRun: globalOpts.dryRun,
+          verbose: globalOpts.verbose
+        }
+      );
+      printJson(data);
+    } catch (error) {
+      printError(error);
+      process.exit(1);
+    }
+  });
+  history.command("stats").description("Get execution statistics").option("--group-id <groupId>", "Filter by policy group").option("--start-date <date>", "Start date (yyyy-MM-dd)").option("--end-date <date>", "End date (yyyy-MM-dd)").action(async (opts) => {
+    try {
+      const globalOpts = program.opts();
+      const format = globalOpts.format ?? "json";
+      const params = {};
+      if (opts.groupId) params.policyGroupId = opts.groupId;
+      if (opts.startDate) params.startDate = opts.startDate;
+      if (opts.endDate) params.endDate = opts.endDate;
+      const data = await apiRequest(
+        "GET",
+        "execution/history/stats",
+        {
+          apiKey: globalOpts.apiKey,
+          baseUrl: globalOpts.baseUrl,
+          dryRun: globalOpts.dryRun,
+          verbose: globalOpts.verbose,
+          params
+        }
+      );
+      if (format === "table") {
+        printTable(
+          ["Total", "Success", "No Match", "Failures", "Success Rate", "Avg Latency"],
+          [[
+            String(data.totalExecutions),
+            String(data.successCount),
+            String(data.noMatchCount),
+            String(data.failureCount),
+            `${data.successRate}%`,
+            `${data.avgLatencyMs}ms`
+          ]]
+        );
+      } else {
+        printJson(data);
+      }
+    } catch (error) {
+      printError(error);
+      process.exit(1);
+    }
+  });
+}
+
+// src/commands/integrations.ts
+import "commander";
+function registerIntegrationCommands(program) {
+  const integrations = program.command("integrations").description("Manage external integrations");
+  integrations.command("list").description("List integrations").option("--type <type>", "Filter by type (COUPON, POINT, NOTIFICATION, CRM, MESSENGER, WEBHOOK)").option("--page <number>", "Page number", "0").option("--size <number>", "Page size", "20").action(async (opts) => {
+    try {
+      const globalOpts = program.opts();
+      const format = globalOpts.format ?? "json";
+      const params = {
+        page: opts.page,
+        size: opts.size
+      };
+      if (opts.type) params.type = opts.type;
+      const data = await apiRequest(
+        "GET",
+        "integrations",
+        {
+          apiKey: globalOpts.apiKey,
+          baseUrl: globalOpts.baseUrl,
+          dryRun: globalOpts.dryRun,
+          verbose: globalOpts.verbose,
+          params
+        }
+      );
+      if (format === "table") {
+        printTable(
+          ["ID", "Name", "Type", "URL", "Active"],
+          data.content.map((i) => [
+            i.id.substring(0, 8),
+            i.name,
+            i.type,
+            i.baseUrl,
+            i.isActive ? "\u2713" : "\u2717"
+          ]),
+          { truncate: 28 }
+        );
+        console.log(`
+${data.totalElements} total \xB7 page ${data.pageNo + 1}/${data.totalPages}`);
+      } else {
+        printJson(data);
+      }
+    } catch (error) {
+      printError(error);
+      process.exit(1);
+    }
+  });
+  integrations.command("get").description("Get integration detail").requiredOption("--id <integrationId>", "Integration ID").action(async (opts) => {
+    try {
+      const globalOpts = program.opts();
+      const data = await apiRequest(
+        "GET",
+        `integrations/${opts.id}`,
+        {
+          apiKey: globalOpts.apiKey,
+          baseUrl: globalOpts.baseUrl,
+          dryRun: globalOpts.dryRun,
+          verbose: globalOpts.verbose
+        }
+      );
+      printJson(data);
+    } catch (error) {
+      printError(error);
+      process.exit(1);
+    }
+  });
+  integrations.command("save").description("Create or update an integration").requiredOption("--json <body>", "Request body as JSON string").action(async (opts) => {
+    try {
+      const globalOpts = program.opts();
+      const body = JSON.parse(opts.json);
+      const data = await apiRequest(
+        "POST",
+        "integrations",
+        {
+          apiKey: globalOpts.apiKey,
+          baseUrl: globalOpts.baseUrl,
+          dryRun: globalOpts.dryRun,
+          verbose: globalOpts.verbose,
+          body
+        }
+      );
+      printJson(data);
+    } catch (error) {
+      printError(error);
+      process.exit(1);
+    }
+  });
+  integrations.command("delete").description("Delete an integration").requiredOption("--id <integrationId>", "Integration ID").option("--force", "Skip confirmation prompt").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(`Delete integration ${opts.id}? [y/N] `);
+        rl.close();
+        if (answer.toLowerCase() !== "y") {
+          console.log("Cancelled.");
+          return;
+        }
+      }
+      await apiRequest(
+        "DELETE",
+        `integrations/${opts.id}`,
+        {
+          apiKey: globalOpts.apiKey,
+          baseUrl: globalOpts.baseUrl,
+          dryRun: globalOpts.dryRun,
+          verbose: globalOpts.verbose
+        }
+      );
+      console.log(`\u2713 Integration ${opts.id} deleted.`);
+    } catch (error) {
+      printError(error);
+      process.exit(1);
+    }
+  });
+  integrations.command("config-spec").description("Get integration configuration field specs").action(async () => {
+    try {
+      const globalOpts = program.opts();
+      const data = await apiRequest(
+        "GET",
+        "integrations/config-spec",
+        {
+          apiKey: globalOpts.apiKey,
+          baseUrl: globalOpts.baseUrl,
+          dryRun: globalOpts.dryRun,
+          verbose: globalOpts.verbose
+        }
+      );
+      printJson(data);
+    } catch (error) {
+      printError(error);
+      process.exit(1);
+    }
+  });
+}
+
+// src/commands/logs.ts
+import "commander";
+function registerLogCommands(program) {
+  const logs = program.command("logs").description("Failure logs");
+  logs.command("list").description("List failure logs").option("--category <category>", "Filter by category (INTEGRATION, INTERNAL)").option("--task-type <taskType>", "Filter by task type (COUPON_ISSUE, POINT_EARN, NOTIFICATION_SEND, WEBHOOK_EXECUTE)").option("--status <status>", "Filter by status (PENDING, RESOLVED, IGNORED)").option("--keyword <keyword>", "Search keyword").option("--start-date <date>", "Start date (yyyy-MM-dd)").option("--end-date <date>", "End date (yyyy-MM-dd)").option("--page <number>", "Page number", "0").option("--size <number>", "Page size", "20").action(async (opts) => {
+    try {
+      const globalOpts = program.opts();
+      const format = globalOpts.format ?? "json";
+      const params = {
+        page: opts.page,
+        size: opts.size
+      };
+      if (opts.category) params.category = opts.category;
+      if (opts.taskType) params.taskType = opts.taskType;
+      if (opts.status) params.status = opts.status;
+      if (opts.keyword) params.searchKeyword = opts.keyword;
+      if (opts.startDate) params.startDate = opts.startDate;
+      if (opts.endDate) params.endDate = opts.endDate;
+      const data = await apiRequest(
+        "GET",
+        "failure-logs",
+        {
+          apiKey: globalOpts.apiKey,
+          baseUrl: globalOpts.baseUrl,
+          dryRun: globalOpts.dryRun,
+          verbose: globalOpts.verbose,
+          params
+        }
+      );
+      if (format === "table") {
+        printTable(
+          ["ID", "Category", "Task", "Status", "Retries", "Error", "Created"],
+          data.content.map((l) => [
+            l.id.substring(0, 8),
+            l.category,
+            l.taskType,
+            l.status,
+            String(l.retryCount),
+            l.errorMessage?.substring(0, 24) ?? "\u2013",
+            l.createdAt.substring(0, 16)
+          ]),
+          { truncate: 24 }
+        );
+        console.log(`
+${data.totalElements} total \xB7 page ${data.pageNo + 1}/${data.totalPages}`);
+      } else {
+        printJson(data);
+      }
+    } catch (error) {
+      printError(error);
+      process.exit(1);
+    }
+  });
+  logs.command("get").description("Get failure log detail").requiredOption("--id <logId>", "Log ID").action(async (opts) => {
+    try {
+      const globalOpts = program.opts();
+      const data = await apiRequest(
+        "GET",
+        `failure-logs/${opts.id}`,
+        {
+          apiKey: globalOpts.apiKey,
+          baseUrl: globalOpts.baseUrl,
+          dryRun: globalOpts.dryRun,
+          verbose: globalOpts.verbose
+        }
+      );
+      printJson(data);
+    } catch (error) {
+      printError(error);
+      process.exit(1);
+    }
+  });
+  logs.command("action").description("Process a failure log action (RETRY, IGNORE, RESOLVE)").requiredOption("--id <logId>", "Log ID").requiredOption("--action <action>", "Action: RETRY, IGNORE, or RESOLVE").action(async (opts) => {
+    try {
+      const globalOpts = program.opts();
+      const data = await apiRequest(
+        "POST",
+        `failure-logs/${opts.id}/actions`,
+        {
+          apiKey: globalOpts.apiKey,
+          baseUrl: globalOpts.baseUrl,
+          dryRun: globalOpts.dryRun,
+          verbose: globalOpts.verbose,
+          params: { action: opts.action }
+        }
+      );
+      printJson(data);
+    } catch (error) {
+      printError(error);
+      process.exit(1);
+    }
+  });
+  logs.command("bulk-action").description("Bulk process failure logs").requiredOption("--ids <logIds>", "Comma-separated log IDs").requiredOption("--action <action>", "Action: RETRY, IGNORE, or RESOLVE").action(async (opts) => {
+    try {
+      const globalOpts = program.opts();
+      const logIds = opts.ids.split(",").map((id) => id.trim());
+      const data = await apiRequest(
+        "POST",
+        "failure-logs/bulk-actions",
+        {
+          apiKey: globalOpts.apiKey,
+          baseUrl: globalOpts.baseUrl,
+          dryRun: globalOpts.dryRun,
+          verbose: globalOpts.verbose,
+          body: { logIds, action: opts.action }
+        }
+      );
+      printJson(data);
+    } catch (error) {
+      printError(error);
+      process.exit(1);
+    }
+  });
+}
+
+// src/cli.ts
+var __dirname = dirname(fileURLToPath(import.meta.url));
+function getVersion() {
+  try {
+    const pkg = JSON.parse(readFileSync3(join2(__dirname, "..", "package.json"), "utf-8"));
+    return pkg.version;
+  } catch {
+    return "0.0.0";
+  }
+}
+function createCli() {
+  const program = new Command();
+  program.name("lexq").description("LexQ CLI \u2014 manage policies, simulate rules, and deploy from the terminal.").version(getVersion(), "-V, --version").option("--format <format>", "Output format: json or table", "json").option("--api-key <key>", "Override stored API key").option("--base-url <url>", "Override API base URL").option("--dry-run", "Preview the HTTP request without executing").option("--verbose", "Show request/response details").option("--no-color", "Disable colored output");
+  registerAuthCommands(program);
+  registerStatusCommand(program);
+  registerGroupCommands(program);
+  registerVersionCommands(program);
+  registerRuleCommands(program);
+  registerFactCommands(program);
+  registerDeployCommands(program);
+  registerAnalyticsCommands(program);
+  registerHistoryCommands(program);
+  registerIntegrationCommands(program);
+  registerLogCommands(program);
+  return program;
+}
+
+// src/index.ts
+async function main() {
+  const program = createCli();
+  try {
+    await program.parseAsync(process.argv);
+  } catch (error) {
+    printError(error);
+    process.exit(1);
+  }
+}
+main();
+//# sourceMappingURL=index.js.map