@chanl/cli 2.0.4 → 3.0.0

package/dist/__tests__/cli-base.test.js

@@ -0,0 +1,87 @@
+import { describe, it, expect, beforeEach, afterEach, vi } from "vitest";
+import { createProgram } from "../cli";
+import { configStore } from "../utils/config-store";
+import { ChanlSDK } from "@chanl/sdk";
+import {
+  runCli,
+  makeMockSdk,
+  setupAuthenticatedConfigStore
+} from "./helpers";
+vi.mock("@chanl/sdk", () => ({
+  ChanlSDK: vi.fn()
+}));
+vi.mock("../utils/config-store", () => ({
+  configStore: {
+    getApiKey: vi.fn(),
+    getBaseUrl: vi.fn(() => "https://api.chanl.ai"),
+    getWorkspaceId: vi.fn(() => "ws_123"),
+    getJwtToken: vi.fn(() => null),
+    getAuthMethod: vi.fn(() => null),
+    getAppUrl: vi.fn(() => "https://app.chanl.ai"),
+    getDeployment: vi.fn(() => "cloud"),
+    getApiPrefix: vi.fn(() => "/api/v1"),
+    setApiKey: vi.fn(),
+    setBaseUrl: vi.fn(),
+    setWorkspaceId: vi.fn(),
+    removeApiKey: vi.fn(),
+    clearAuth: vi.fn(),
+    delete: vi.fn(),
+    isAuthenticated: vi.fn(),
+    getPath: vi.fn(() => "/home/user/.chanl/config.json")
+  }
+}));
+describe("CLI", () => {
+  let mockSdk;
+  beforeEach(() => {
+    vi.clearAllMocks();
+    mockSdk = makeMockSdk();
+    ChanlSDK.mockImplementation(() => mockSdk);
+    setupAuthenticatedConfigStore(configStore);
+  });
+  afterEach(() => {
+    process.exitCode = void 0;
+  });
+  describe("--help", () => {
+    it("should have all expected commands in program", () => {
+      const program = createProgram();
+      const commandNames = program.commands.map((c) => c.name());
+      expect(commandNames).toContain("login");
+      expect(commandNames).toContain("logout");
+      expect(commandNames).toContain("auth");
+      expect(commandNames).toContain("config");
+      expect(commandNames).toContain("tools");
+    });
+  });
+  describe("--version", () => {
+    it("should have correct version in program", () => {
+      const program = createProgram();
+      expect(program.version()).toMatch(/^\d+\.\d+\.\d+$/);
+    });
+  });
+  describe("error handling", () => {
+    it("should show error when not authenticated for tools commands", async () => {
+      configStore.getApiKey.mockReturnValue(null);
+      const { exitCode, errors } = await runCli(["tools", "list"]);
+      expect(exitCode).toBe(1);
+      expect(errors.some((e) => e.includes("Not authenticated"))).toBe(true);
+    });
+    it("should handle API errors gracefully", async () => {
+      mockSdk.tools.list.mockRejectedValue(new Error("Network error"));
+      const { exitCode, errors } = await runCli(["tools", "list"]);
+      expect(exitCode).toBe(1);
+      expect(errors.some((e) => e.includes("Network error"))).toBe(true);
+    });
+    it("should handle unsuccessful API responses", async () => {
+      mockSdk.tools.list.mockResolvedValue({
+        success: false,
+        data: null,
+        message: "Unauthorized",
+        timestamp: (/* @__PURE__ */ new Date()).toISOString()
+      });
+      const { exitCode, errors } = await runCli(["tools", "list"]);
+      expect(exitCode).toBe(1);
+      expect(errors.some((e) => e.includes("Unauthorized") || e.includes("Failed"))).toBe(true);
+    });
+  });
+});
+//# sourceMappingURL=cli-base.test.js.map

package/dist/__tests__/cli-base.test.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/__tests__/cli-base.test.ts"],"sourcesContent":["/**\n * CLI base tests — --help, --version, error handling\n */\n\nimport { describe, it, expect, beforeEach, afterEach, vi, Mock } from 'vitest';\nimport { createProgram } from '../cli';\nimport { configStore } from '../utils/config-store';\nimport { ChanlSDK } from '@chanl/sdk';\nimport {\n  runCli,\n  makeMockSdk,\n  setupAuthenticatedConfigStore,\n  type MockSdk,\n} from './helpers';\n\n// Mock the SDK\nvi.mock('@chanl/sdk', () => ({\n  ChanlSDK: vi.fn(),\n}));\n\n// Mock config store\nvi.mock('../utils/config-store', () => ({\n  configStore: {\n    getApiKey: vi.fn(),\n    getBaseUrl: vi.fn(() => 'https://api.chanl.ai'),\n    getWorkspaceId: vi.fn(() => 'ws_123'),\n    getJwtToken: vi.fn(() => null),\n    getAuthMethod: vi.fn(() => null),\n    getAppUrl: vi.fn(() => 'https://app.chanl.ai'),\n    getDeployment: vi.fn(() => 'cloud'),\n    getApiPrefix: vi.fn(() => '/api/v1'),\n    setApiKey: vi.fn(),\n    setBaseUrl: vi.fn(),\n    setWorkspaceId: vi.fn(),\n    removeApiKey: vi.fn(),\n    clearAuth: vi.fn(),\n    delete: vi.fn(),\n    isAuthenticated: vi.fn(),\n    getPath: vi.fn(() => '/home/user/.chanl/config.json'),\n  },\n}));\n\ndescribe('CLI', () => {\n  let mockSdk: MockSdk;\n\n  beforeEach(() => {\n    // Reset mocks\n    vi.clearAllMocks();\n\n    // Setup mock SDK\n    mockSdk = makeMockSdk();\n\n    (ChanlSDK as Mock).mockImplementation(() => mockSdk);\n\n    // Default: authenticated with workspace\n    setupAuthenticatedConfigStore(configStore as unknown as {\n      getApiKey: Mock;\n      getWorkspaceId: Mock;\n      isAuthenticated: Mock;\n    });\n  });\n\n  afterEach(() => {\n    process.exitCode = undefined;\n  });\n\n  describe('--help', () => {\n    it('should have all expected commands in program', () => {\n      // Test program structure instead of output since Commander uses stdout.write\n      const program = createProgram();\n      const commandNames = program.commands.map((c) => c.name());\n\n      expect(commandNames).toContain('login');\n      expect(commandNames).toContain('logout');\n      expect(commandNames).toContain('auth');\n      expect(commandNames).toContain('config');\n      expect(commandNames).toContain('tools');\n    });\n  });\n\n  describe('--version', () => {\n    it('should have correct version in program', () => {\n      // Test program version instead of output since Commander uses stdout.write\n      const program = createProgram();\n      // Version is dynamically read from package.json\n      expect(program.version()).toMatch(/^\\d+\\.\\d+\\.\\d+$/);\n    });\n  });\n\n  describe('error handling', () => {\n    it('should show error when not authenticated for tools commands', async () => {\n      (configStore.getApiKey as Mock).mockReturnValue(null);\n\n      const { exitCode, errors } = await runCli(['tools', 'list']);\n\n      expect(exitCode).toBe(1);\n      expect(errors.some((e) => e.includes('Not authenticated'))).toBe(true);\n    });\n\n    it('should handle API errors gracefully', async () => {\n      mockSdk.tools.list.mockRejectedValue(new Error('Network error'));\n\n      const { exitCode, errors } = await runCli(['tools', 'list']);\n\n      expect(exitCode).toBe(1);\n      expect(errors.some((e) => e.includes('Network error'))).toBe(true);\n    });\n\n    it('should handle unsuccessful API responses', async () => {\n      mockSdk.tools.list.mockResolvedValue({\n        success: false,\n        data: null,\n        message: 'Unauthorized',\n        timestamp: new Date().toISOString(),\n      });\n\n      const { exitCode, errors } = await runCli(['tools', 'list']);\n\n      expect(exitCode).toBe(1);\n      expect(errors.some((e) => e.includes('Unauthorized') || e.includes('Failed'))).toBe(true);\n    });\n  });\n});\n"],"mappings":"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","names":[]}

package/dist/__tests__/cli-missing.test.d.ts

@@ -0,0 +1,2 @@
+
+export {  }

package/dist/__tests__/cli-missing.test.js

@@ -0,0 +1,546 @@
+import {
+  describe,
+  it,
+  expect,
+  beforeEach,
+  afterEach,
+  vi
+} from "vitest";
+import { createProgram } from "../cli";
+import { configStore } from "../utils/config-store";
+import { ChanlSDK } from "@chanl/sdk";
+vi.mock("@chanl/sdk", () => ({
+  ChanlSDK: vi.fn()
+}));
+vi.mock("../utils/config-store", () => ({
+  configStore: {
+    // Read accessors (used by sdk-factory + individual commands)
+    getApiKey: vi.fn(() => "test-api-key"),
+    getBaseUrl: vi.fn(() => "https://api.chanl.ai"),
+    getWorkspaceId: vi.fn(() => "ws_123"),
+    getJwtToken: vi.fn(() => null),
+    getAuthMethod: vi.fn(() => null),
+    getAppUrl: vi.fn(() => "https://app.chanl.ai"),
+    getDeployment: vi.fn(() => "cloud"),
+    getApiPrefix: vi.fn(() => "/api/v1"),
+    getPath: vi.fn(() => "/home/user/.chanl/config.json"),
+    // Mutators
+    set: vi.fn(),
+    get: vi.fn(),
+    has: vi.fn(() => false),
+    delete: vi.fn(),
+    getAll: vi.fn(() => ({
+      apiKey: "test-api-key",
+      baseUrl: "https://api.chanl.ai",
+      workspaceId: "ws_123"
+    })),
+    setApiKey: vi.fn(),
+    setBaseUrl: vi.fn(),
+    setWorkspaceId: vi.fn(),
+    removeApiKey: vi.fn(),
+    clearAuth: vi.fn(),
+    isAuthenticated: vi.fn(() => true)
+  }
+}));
+function captureOutput() {
+  const logs = [];
+  const errors = [];
+  const origLog = console.log;
+  const origErr = console.error;
+  console.log = (...args) => {
+    logs.push(args.map(String).join(" "));
+  };
+  console.error = (...args) => {
+    errors.push(args.map(String).join(" "));
+  };
+  return {
+    logs,
+    errors,
+    restore: () => {
+      console.log = origLog;
+      console.error = origErr;
+    }
+  };
+}
+async function runCli(args) {
+  const out = captureOutput();
+  const program = createProgram();
+  process.exitCode = void 0;
+  try {
+    await program.parseAsync(["node", "chanl", ...args]);
+  } catch {
+  }
+  out.restore();
+  return {
+    exitCode: process.exitCode ?? 0,
+    logs: out.logs,
+    errors: out.errors
+  };
+}
+function makeMockSdk() {
+  return {
+    memory: {
+      list: vi.fn(),
+      get: vi.fn(),
+      create: vi.fn(),
+      update: vi.fn(),
+      delete: vi.fn(),
+      search: vi.fn(),
+      extract: vi.fn(),
+      bulkDelete: vi.fn()
+    },
+    knowledge: {
+      list: vi.fn(),
+      get: vi.fn(),
+      create: vi.fn(),
+      update: vi.fn(),
+      delete: vi.fn(),
+      search: vi.fn(),
+      getTaskStatus: vi.fn(),
+      getChunks: vi.fn()
+    },
+    personas: {
+      list: vi.fn(),
+      get: vi.fn(),
+      create: vi.fn(),
+      update: vi.fn(),
+      delete: vi.fn()
+    },
+    scorecard: {
+      list: vi.fn(),
+      get: vi.fn(),
+      create: vi.fn(),
+      update: vi.fn(),
+      delete: vi.fn()
+    },
+    health: {
+      getHealth: vi.fn(),
+      getDetailedHealth: vi.fn()
+    }
+  };
+}
+describe("CLI (missing commands)", () => {
+  let mockSdk;
+  beforeEach(() => {
+    vi.clearAllMocks();
+    mockSdk = makeMockSdk();
+    ChanlSDK.mockImplementation(() => mockSdk);
+    configStore.getApiKey.mockReturnValue("test-api-key");
+    configStore.getWorkspaceId.mockReturnValue("ws_123");
+    configStore.isAuthenticated.mockReturnValue(true);
+  });
+  afterEach(() => {
+    process.exitCode = void 0;
+  });
+  describe("config list", () => {
+    it("reads all values from configStore.getAll", async () => {
+      configStore.getAll.mockReturnValueOnce({
+        apiKey: "ak_secret",
+        baseUrl: "https://api.chanl.ai",
+        workspaceId: "ws_1"
+      });
+      const { exitCode } = await runCli(["config", "list"]);
+      expect(exitCode).toBe(0);
+      expect(configStore.getAll).toHaveBeenCalled();
+    });
+  });
+  describe("config get", () => {
+    it("reads a single key via configStore.getApiKey", async () => {
+      await runCli(["config", "get", "apiKey"]);
+      expect(configStore.getApiKey).toHaveBeenCalled();
+    });
+    it("exits 1 on an unknown key", async () => {
+      const { exitCode, errors } = await runCli([
+        "config",
+        "get",
+        "nonexistentKey"
+      ]);
+      expect(exitCode).toBe(1);
+      expect(errors.some((e) => e.includes("Unknown configuration key"))).toBe(
+        true
+      );
+    });
+  });
+  describe("config set", () => {
+    it("writes via configStore.set with the provided key + value", async () => {
+      const { exitCode } = await runCli([
+        "config",
+        "set",
+        "workspaceId",
+        "ws_new"
+      ]);
+      expect(exitCode).toBe(0);
+      expect(configStore.set).toHaveBeenCalledWith("workspaceId", "ws_new");
+    });
+    it("rejects invalid baseUrl values", async () => {
+      const { exitCode, errors } = await runCli([
+        "config",
+        "set",
+        "baseUrl",
+        "not-a-url"
+      ]);
+      expect(exitCode).toBe(1);
+      expect(errors.some((e) => e.includes("Invalid URL"))).toBe(true);
+    });
+    it("rejects invalid defaultFormat", async () => {
+      const { exitCode, errors } = await runCli([
+        "config",
+        "set",
+        "defaultFormat",
+        "xml"
+      ]);
+      expect(exitCode).toBe(1);
+      expect(errors.some((e) => e.includes("Invalid format"))).toBe(true);
+    });
+    it("rejects unknown config keys", async () => {
+      const { exitCode, errors } = await runCli([
+        "config",
+        "set",
+        "bogus",
+        "anything"
+      ]);
+      expect(exitCode).toBe(1);
+      expect(errors.some((e) => e.includes("Unknown configuration key"))).toBe(
+        true
+      );
+    });
+    it("clears a stale `server` alias when setting baseUrl, so the change actually takes effect", async () => {
+      configStore.has.mockReturnValueOnce(true);
+      const { exitCode, logs } = await runCli([
+        "config",
+        "set",
+        "baseUrl",
+        "http://localhost:3100"
+      ]);
+      expect(exitCode).toBe(0);
+      expect(configStore.set).toHaveBeenCalledWith("baseUrl", "http://localhost:3100");
+      expect(configStore.delete).toHaveBeenCalledWith("server");
+      expect(logs.join("\n")).toContain("cleared 'server'");
+    });
+    it("does not touch `server` when it was not set", async () => {
+      configStore.has.mockReturnValueOnce(false);
+      const { exitCode } = await runCli([
+        "config",
+        "set",
+        "baseUrl",
+        "http://localhost:3100"
+      ]);
+      expect(exitCode).toBe(0);
+      expect(configStore.delete).not.toHaveBeenCalled();
+    });
+    it("does not touch `server` when setting an unrelated key", async () => {
+      const { exitCode } = await runCli(["config", "set", "workspaceId", "ws_new"]);
+      expect(exitCode).toBe(0);
+      expect(configStore.delete).not.toHaveBeenCalled();
+    });
+  });
+  describe("config use", () => {
+    it("switches baseUrl to the preset for a known environment", async () => {
+      const { exitCode, logs } = await runCli(["config", "use", "production"]);
+      expect(exitCode).toBe(0);
+      expect(configStore.set).toHaveBeenCalledWith("baseUrl", "https://platform.chanl.ai");
+      expect(logs.join("\n")).toContain("platform.chanl.ai");
+    });
+    it("clears a stale `server` alias so the switch actually takes effect", async () => {
+      configStore.has.mockReturnValueOnce(true);
+      const { exitCode, logs } = await runCli(["config", "use", "production"]);
+      expect(exitCode).toBe(0);
+      expect(configStore.delete).toHaveBeenCalledWith("server");
+      expect(logs.join("\n")).toContain("cleared 'server'");
+    });
+    it("rejects an unknown environment", async () => {
+      const { exitCode, errors } = await runCli(["config", "use", "bogus-env"]);
+      expect(exitCode).toBe(1);
+      expect(errors.some((e) => e.includes("Unknown environment"))).toBe(true);
+      expect(configStore.set).not.toHaveBeenCalled();
+    });
+  });
+  describe("config delete", () => {
+    it("returns success silently when key was never set", async () => {
+      configStore.has.mockReturnValueOnce(false);
+      const { exitCode } = await runCli(["config", "delete", "workspaceId"]);
+      expect(exitCode).toBe(0);
+      expect(configStore.delete).not.toHaveBeenCalled();
+    });
+    it("calls configStore.delete when key exists", async () => {
+      configStore.has.mockReturnValueOnce(true);
+      const { exitCode } = await runCli(["config", "delete", "workspaceId"]);
+      expect(exitCode).toBe(0);
+      expect(configStore.delete).toHaveBeenCalledWith("workspaceId");
+    });
+  });
+  describe("health", () => {
+    it("calls sdk.health.getHealth() and prints status", async () => {
+      mockSdk.health.getHealth.mockResolvedValueOnce({
+        success: true,
+        data: {
+          status: "ok",
+          timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+          version: "2.0.4",
+          uptime: 3600
+        },
+        message: "OK",
+        timestamp: (/* @__PURE__ */ new Date()).toISOString()
+      });
+      const { exitCode, logs } = await runCli(["health"]);
+      expect(exitCode).toBe(0);
+      expect(mockSdk.health.getHealth).toHaveBeenCalled();
+      const output = logs.join("\n");
+      expect(output).toContain("healthy");
+    });
+    it("exits 1 on network error", async () => {
+      mockSdk.health.getHealth.mockRejectedValueOnce(new Error("Connection refused"));
+      const { exitCode, errors } = await runCli(["health"]);
+      expect(exitCode).toBe(1);
+      expect(errors.join("\n")).toContain("Connection refused");
+    });
+    it("outputs JSON with --json flag", async () => {
+      mockSdk.health.getHealth.mockResolvedValueOnce({
+        success: true,
+        data: {
+          status: "ok",
+          timestamp: "2026-04-09T00:00:00Z",
+          version: "2.0.4",
+          uptime: 100
+        },
+        message: "OK",
+        timestamp: "2026-04-09T00:00:00Z"
+      });
+      const { exitCode, logs } = await runCli(["health", "--json"]);
+      expect(exitCode).toBe(0);
+      const parsed = JSON.parse(logs.join(""));
+      expect(parsed.status).toBe("ok");
+    });
+  });
+  describe("memory list", () => {
+    it("calls sdk.memory.list with default pagination", async () => {
+      mockSdk.memory.list.mockResolvedValueOnce({
+        success: true,
+        data: { memories: [], total: 0 },
+        message: "OK",
+        timestamp: (/* @__PURE__ */ new Date()).toISOString()
+      });
+      const { exitCode } = await runCli(["memory", "list"]);
+      expect(exitCode).toBe(0);
+      expect(mockSdk.memory.list).toHaveBeenCalledWith(
+        expect.objectContaining({ page: 1, limit: 20 })
+      );
+    });
+    it("forwards filters from flags", async () => {
+      mockSdk.memory.list.mockResolvedValueOnce({
+        success: true,
+        data: { memories: [], total: 0 },
+        message: "OK",
+        timestamp: (/* @__PURE__ */ new Date()).toISOString()
+      });
+      await runCli([
+        "memory",
+        "list",
+        "--entity-type",
+        "customer",
+        "--entity-id",
+        "cust_1",
+        "--agent-id",
+        "ag_1",
+        "--source",
+        "manual",
+        "--limit",
+        "50",
+        "--page",
+        "2"
+      ]);
+      expect(mockSdk.memory.list).toHaveBeenCalledWith(
+        expect.objectContaining({
+          entityType: "customer",
+          entityId: "cust_1",
+          agentId: "ag_1",
+          source: "manual",
+          limit: 50,
+          page: 2
+        })
+      );
+    });
+    it('prints "No memories found" on empty result', async () => {
+      mockSdk.memory.list.mockResolvedValueOnce({
+        success: true,
+        data: { memories: [], total: 0 },
+        message: "OK",
+        timestamp: (/* @__PURE__ */ new Date()).toISOString()
+      });
+      const { logs } = await runCli(["memory", "list"]);
+      expect(logs.join("\n")).toContain("No memories found");
+    });
+    it("exits 1 on SDK error", async () => {
+      mockSdk.memory.list.mockRejectedValueOnce(new Error("Forbidden"));
+      const { exitCode, errors } = await runCli(["memory", "list"]);
+      expect(exitCode).toBe(1);
+      expect(errors.join("\n")).toContain("Forbidden");
+    });
+  });
+  describe("memory get", () => {
+    it("fetches by ID", async () => {
+      mockSdk.memory.get.mockResolvedValueOnce({
+        success: true,
+        data: {
+          id: "mem_1",
+          entityType: "customer",
+          entityId: "cust_1",
+          content: "Prefers email",
+          isActive: true,
+          createdAt: "2026-04-09T00:00:00Z"
+        },
+        message: "OK",
+        timestamp: (/* @__PURE__ */ new Date()).toISOString()
+      });
+      const { exitCode } = await runCli(["memory", "get", "mem_1"]);
+      expect(exitCode).toBe(0);
+      expect(mockSdk.memory.get).toHaveBeenCalledWith("mem_1");
+    });
+  });
+  describe("memory search", () => {
+    it("requires entity-type, entity-id, and query", async () => {
+      mockSdk.memory.search.mockResolvedValueOnce({
+        success: true,
+        data: {
+          memories: [
+            {
+              id: "mem_1",
+              content: "prefers email",
+              score: 0.92,
+              entityType: "customer",
+              entityId: "cust_1",
+              createdAt: "2026-04-09T00:00:00Z"
+            }
+          ]
+        },
+        message: "OK",
+        timestamp: (/* @__PURE__ */ new Date()).toISOString()
+      });
+      const { exitCode } = await runCli([
+        "memory",
+        "search",
+        "--entity-type",
+        "customer",
+        "--entity-id",
+        "cust_1",
+        "--query",
+        "email preferences",
+        "--limit",
+        "5"
+      ]);
+      expect(exitCode).toBe(0);
+      expect(mockSdk.memory.search).toHaveBeenCalledWith(
+        expect.objectContaining({
+          entityType: "customer",
+          entityId: "cust_1",
+          query: "email preferences",
+          limit: 5
+        })
+      );
+    });
+  });
+  describe("knowledge list", () => {
+    it("calls sdk.knowledge.list", async () => {
+      mockSdk.knowledge.list.mockResolvedValueOnce({
+        success: true,
+        data: { items: [], total: 0 },
+        message: "OK",
+        timestamp: (/* @__PURE__ */ new Date()).toISOString()
+      });
+      const { exitCode } = await runCli(["knowledge", "list"]);
+      expect(exitCode).toBe(0);
+      expect(mockSdk.knowledge.list).toHaveBeenCalled();
+    });
+  });
+  describe("knowledge search", () => {
+    it("calls sdk.knowledge.search with query body", async () => {
+      mockSdk.knowledge.search.mockResolvedValueOnce({
+        success: true,
+        data: { results: [] },
+        message: "OK",
+        timestamp: (/* @__PURE__ */ new Date()).toISOString()
+      });
+      const { exitCode } = await runCli([
+        "knowledge",
+        "search",
+        "how to return"
+      ]);
+      expect(exitCode).toBe(0);
+      expect(mockSdk.knowledge.search).toHaveBeenCalledWith(
+        expect.objectContaining({ query: "how to return" })
+      );
+    });
+  });
+  describe("personas list", () => {
+    it("calls sdk.personas.list", async () => {
+      mockSdk.personas.list.mockResolvedValueOnce({
+        success: true,
+        data: { personas: [], total: 0 },
+        message: "OK",
+        timestamp: (/* @__PURE__ */ new Date()).toISOString()
+      });
+      const { exitCode } = await runCli(["personas", "list"]);
+      expect(exitCode).toBe(0);
+      expect(mockSdk.personas.list).toHaveBeenCalled();
+    });
+  });
+  describe("personas get", () => {
+    it("calls sdk.personas.get with id", async () => {
+      mockSdk.personas.get.mockResolvedValueOnce({
+        success: true,
+        data: {
+          id: "p_1",
+          name: "Frustrated Customer",
+          gender: "female",
+          emotion: "frustrated",
+          language: "english",
+          accent: "american",
+          intentClarity: "very clear",
+          speechStyle: "fast",
+          backgroundNoise: false,
+          allowInterruptions: true,
+          backstory: "Bad shipping",
+          isActive: true,
+          createdAt: "2026-04-09T00:00:00Z",
+          updatedAt: "2026-04-09T00:00:00Z"
+        },
+        message: "OK",
+        timestamp: (/* @__PURE__ */ new Date()).toISOString()
+      });
+      const { exitCode } = await runCli(["personas", "get", "p_1"]);
+      expect(exitCode).toBe(0);
+      expect(mockSdk.personas.get).toHaveBeenCalledWith("p_1");
+    });
+  });
+  describe("scorecards list", () => {
+    it("calls sdk.scorecard.list", async () => {
+      mockSdk.scorecard.list.mockResolvedValueOnce({
+        success: true,
+        data: { scorecards: [], total: 0 },
+        message: "OK",
+        timestamp: (/* @__PURE__ */ new Date()).toISOString()
+      });
+      const { exitCode } = await runCli(["scorecards", "list"]);
+      expect(exitCode).toBe(0);
+      expect(mockSdk.scorecard.list).toHaveBeenCalled();
+    });
+  });
+  describe("scorecards get", () => {
+    it("calls sdk.scorecard.get with id", async () => {
+      mockSdk.scorecard.get.mockResolvedValueOnce({
+        success: true,
+        data: {
+          id: "sc_1",
+          name: "Customer Quality",
+          status: "active"
+        },
+        message: "OK",
+        timestamp: (/* @__PURE__ */ new Date()).toISOString()
+      });
+      const { exitCode } = await runCli(["scorecards", "get", "sc_1"]);
+      expect(exitCode).toBe(0);
+      expect(mockSdk.scorecard.get).toHaveBeenCalledWith("sc_1");
+    });
+  });
+});
+//# sourceMappingURL=cli-missing.test.js.map