@kb-labs/shared-testing 1.0.0

package/dist/index.js

@@ -0,0 +1,916 @@
+import { resetPlatform, platform } from '@kb-labs/core-runtime';
+import { vi } from 'vitest';
+
+// src/setup-platform.ts
+function setupTestPlatform(options = {}) {
+  resetPlatform();
+  const adapterMap = [
+    ["llm", options.llm],
+    ["cache", options.cache],
+    ["embeddings", options.embeddings],
+    ["vectorStore", options.vectorStore],
+    ["storage", options.storage],
+    ["analytics", options.analytics],
+    ["logger", options.logger],
+    ["eventBus", options.eventBus]
+  ];
+  for (const [key, instance] of adapterMap) {
+    if (instance !== void 0) {
+      platform.setAdapter(key, instance);
+    }
+  }
+  return {
+    platform,
+    cleanup: () => resetPlatform()
+  };
+}
+var MockLLMBuilder = class {
+  rules = [];
+  defaultResponse = "mock response";
+  streamChunks = ["mock"];
+  errorToThrow = null;
+  toolCallsToReturn = [];
+  toolCallResponseContent = "";
+  /**
+   * Match a specific prompt (exact string or regex).
+   * Returns a handler to set the response.
+   */
+  onComplete(matcher) {
+    return {
+      respondWith: (response) => {
+        this.rules.push({ matcher, response });
+        return this;
+      }
+    };
+  }
+  /**
+   * Set the default response for any prompt that doesn't match a rule.
+   */
+  onAnyComplete() {
+    return {
+      respondWith: (response) => {
+        this.defaultResponse = response;
+        return this;
+      }
+    };
+  }
+  /**
+   * Configure streaming to yield specific chunks.
+   */
+  streaming(chunks) {
+    this.streamChunks = chunks;
+    return this;
+  }
+  /**
+   * Make the LLM throw an error on every call.
+   */
+  failing(error) {
+    this.errorToThrow = error;
+    return this;
+  }
+  /**
+   * Configure chatWithTools() to return specific tool calls.
+   */
+  withToolCalls(calls, content = "") {
+    this.toolCallsToReturn = calls;
+    this.toolCallResponseContent = content;
+    return this;
+  }
+  /**
+   * Build the mock ILLM instance. Called automatically by mockLLM().
+   */
+  build() {
+    const calls = [];
+    const toolCallRecords = [];
+    const rules = this.rules;
+    const defaultResponse = this.defaultResponse;
+    const streamChunks = this.streamChunks;
+    const errorToThrow = this.errorToThrow;
+    const toolCallsToReturn = this.toolCallsToReturn;
+    const toolCallResponseContent = this.toolCallResponseContent;
+    function resolveResponse(prompt) {
+      for (const rule of rules) {
+        if (matchesPrompt(rule.matcher, prompt)) {
+          return toResponse(rule.response, prompt);
+        }
+      }
+      return toResponse(defaultResponse, prompt);
+    }
+    const completeFn = vi.fn(async (prompt, options) => {
+      if (errorToThrow) {
+        throw errorToThrow;
+      }
+      const response = resolveResponse(prompt);
+      calls.push({ prompt, options, response });
+      return response;
+    });
+    const streamFn = vi.fn(async function* (_prompt, _options) {
+      if (errorToThrow) {
+        throw errorToThrow;
+      }
+      for (const chunk of streamChunks) {
+        yield chunk;
+      }
+    });
+    const chatWithToolsFn = vi.fn(async (messages, options) => {
+      if (errorToThrow) {
+        throw errorToThrow;
+      }
+      const lastUserMsg = messages.filter((m) => m.role === "user").pop();
+      const prompt = lastUserMsg?.content ?? "";
+      const baseResponse = resolveResponse(prompt);
+      const response = {
+        ...baseResponse,
+        content: toolCallsToReturn.length > 0 ? toolCallResponseContent : baseResponse.content,
+        toolCalls: toolCallsToReturn.length > 0 ? toolCallsToReturn : void 0
+      };
+      toolCallRecords.push({ messages, options, response });
+      return response;
+    });
+    const instance = {
+      complete: completeFn,
+      stream: streamFn,
+      chatWithTools: chatWithToolsFn,
+      calls,
+      toolCalls: toolCallRecords,
+      get lastCall() {
+        return calls[calls.length - 1];
+      },
+      resetCalls: () => {
+        calls.length = 0;
+        toolCallRecords.length = 0;
+        completeFn.mockClear();
+        streamFn.mockClear();
+        chatWithToolsFn.mockClear();
+      }
+    };
+    return instance;
+  }
+};
+function matchesPrompt(matcher, prompt) {
+  if (typeof matcher === "string") {
+    return prompt.includes(matcher);
+  }
+  if (matcher instanceof RegExp) {
+    return matcher.test(prompt);
+  }
+  return matcher(prompt);
+}
+function toResponse(value, prompt) {
+  const resolved = typeof value === "function" ? value(prompt) : value;
+  if (typeof resolved === "string") {
+    return {
+      content: resolved,
+      usage: { promptTokens: 0, completionTokens: 0 },
+      model: "mock"
+    };
+  }
+  return resolved;
+}
+function mockLLM() {
+  const builder = new MockLLMBuilder();
+  let built = null;
+  function ensureBuilt() {
+    if (!built) {
+      built = builder.build();
+    }
+    return built;
+  }
+  const proxy = new Proxy(builder, {
+    get(target, prop, _receiver) {
+      if (prop in target && typeof target[prop] === "function") {
+        const method = target[prop].bind(target);
+        return (...args) => {
+          built = null;
+          const result = method(...args);
+          if (result === target || result && typeof result === "object" && "respondWith" in result) {
+            if (result === target) {
+              return proxy;
+            }
+            return {
+              respondWith: (...rArgs) => {
+                built = null;
+                result.respondWith(...rArgs);
+                return proxy;
+              }
+            };
+          }
+          return result;
+        };
+      }
+      const instance = ensureBuilt();
+      return instance[prop];
+    }
+  });
+  return proxy;
+}
+function mockCache(initial) {
+  const store = /* @__PURE__ */ new Map();
+  const sortedSets = /* @__PURE__ */ new Map();
+  if (initial) {
+    for (const [key, value] of Object.entries(initial)) {
+      store.set(key, { value, expiresAt: null });
+    }
+  }
+  function isExpired(entry) {
+    return entry.expiresAt !== null && Date.now() > entry.expiresAt;
+  }
+  const spies = [];
+  function spy(fn) {
+    const s = vi.fn(fn);
+    spies.push(s);
+    return s;
+  }
+  const getFn = spy(async (key) => {
+    const entry = store.get(key);
+    if (!entry || isExpired(entry)) {
+      if (entry) {
+        store.delete(key);
+      }
+      return null;
+    }
+    return entry.value;
+  });
+  const setFn = spy(async (key, value, ttl) => {
+    store.set(key, {
+      value,
+      expiresAt: ttl ? Date.now() + ttl : null
+    });
+  });
+  const deleteFn = spy(async (key) => {
+    store.delete(key);
+  });
+  const clearFn = spy(async (pattern) => {
+    if (!pattern) {
+      store.clear();
+      return;
+    }
+    const prefix = pattern.replace(/\*$/, "");
+    for (const key of store.keys()) {
+      if (key.startsWith(prefix)) {
+        store.delete(key);
+      }
+    }
+  });
+  const zaddFn = spy(async (key, score, member) => {
+    if (!sortedSets.has(key)) {
+      sortedSets.set(key, []);
+    }
+    const set = sortedSets.get(key);
+    const idx = set.findIndex((m) => m.member === member);
+    if (idx >= 0) {
+      set.splice(idx, 1);
+    }
+    set.push({ score, member });
+    set.sort((a, b) => a.score - b.score);
+  });
+  const zrangebyscoreFn = spy(async (key, min, max) => {
+    const set = sortedSets.get(key);
+    if (!set) {
+      return [];
+    }
+    return set.filter((m) => m.score >= min && m.score <= max).map((m) => m.member);
+  });
+  const zremFn = spy(async (key, member) => {
+    const set = sortedSets.get(key);
+    if (!set) {
+      return;
+    }
+    const idx = set.findIndex((m) => m.member === member);
+    if (idx >= 0) {
+      set.splice(idx, 1);
+    }
+  });
+  const setIfNotExistsFn = spy(async (key, value, ttl) => {
+    const existing = store.get(key);
+    if (existing && !isExpired(existing)) {
+      return false;
+    }
+    store.set(key, {
+      value,
+      expiresAt: ttl ? Date.now() + ttl : null
+    });
+    return true;
+  });
+  const instance = {
+    get: getFn,
+    set: setFn,
+    delete: deleteFn,
+    clear: clearFn,
+    zadd: zaddFn,
+    zrangebyscore: zrangebyscoreFn,
+    zrem: zremFn,
+    setIfNotExists: setIfNotExistsFn,
+    get store() {
+      return store;
+    },
+    get sortedSets() {
+      return sortedSets;
+    },
+    reset: () => {
+      store.clear();
+      sortedSets.clear();
+      for (const s of spies) {
+        s.mockClear();
+      }
+    }
+  };
+  return instance;
+}
+function mockStorage(initial) {
+  const files = /* @__PURE__ */ new Map();
+  if (initial) {
+    for (const [path, content] of Object.entries(initial)) {
+      files.set(path, typeof content === "string" ? Buffer.from(content) : content);
+    }
+  }
+  const readFn = vi.fn(async (path) => {
+    return files.get(path) ?? null;
+  });
+  const writeFn = vi.fn(async (path, data) => {
+    files.set(path, data);
+  });
+  const deleteFn = vi.fn(async (path) => {
+    files.delete(path);
+  });
+  const listFn = vi.fn(async (prefix) => {
+    const result = [];
+    for (const path of files.keys()) {
+      if (path.startsWith(prefix)) {
+        result.push(path);
+      }
+    }
+    return result.sort();
+  });
+  const existsFn = vi.fn(async (path) => {
+    return files.has(path);
+  });
+  const instance = {
+    read: readFn,
+    write: writeFn,
+    delete: deleteFn,
+    list: listFn,
+    exists: existsFn,
+    get files() {
+      return files;
+    },
+    reset: () => {
+      files.clear();
+      readFn.mockClear();
+      writeFn.mockClear();
+      deleteFn.mockClear();
+      listFn.mockClear();
+      existsFn.mockClear();
+    }
+  };
+  return instance;
+}
+function mockLogger(sharedMessages) {
+  const messages = sharedMessages ?? [];
+  function createSimpleLogMethod(level) {
+    return vi.fn((msg, meta) => {
+      messages.push({ level, msg, meta });
+    });
+  }
+  function createErrorLogMethod(level) {
+    return vi.fn((msg, error, meta) => {
+      messages.push({ level, msg, error, meta });
+    });
+  }
+  const instance = {
+    trace: createSimpleLogMethod("trace"),
+    debug: createSimpleLogMethod("debug"),
+    info: createSimpleLogMethod("info"),
+    warn: createSimpleLogMethod("warn"),
+    error: createErrorLogMethod("error"),
+    fatal: createErrorLogMethod("fatal"),
+    child: (_bindings) => mockLogger(messages),
+    get messages() {
+      return messages;
+    },
+    reset: () => {
+      messages.length = 0;
+      instance.trace.mockClear();
+      instance.debug.mockClear();
+      instance.info.mockClear();
+      instance.warn.mockClear();
+      instance.error.mockClear();
+      instance.fatal.mockClear();
+    }
+  };
+  return instance;
+}
+function createMockTrace() {
+  return {
+    traceId: "test-trace-id",
+    spanId: "test-span-id",
+    parentSpanId: void 0,
+    addEvent: () => {
+    },
+    setAttribute: () => {
+    },
+    recordError: () => {
+    }
+  };
+}
+function createMockUI() {
+  const messages = [];
+  const mockColor = (text) => text;
+  const mockColors = {
+    success: mockColor,
+    error: mockColor,
+    warning: mockColor,
+    info: mockColor,
+    primary: mockColor,
+    accent: mockColor,
+    highlight: mockColor,
+    secondary: mockColor,
+    emphasis: mockColor,
+    muted: mockColor,
+    foreground: mockColor,
+    dim: mockColor,
+    bold: mockColor,
+    underline: mockColor,
+    inverse: mockColor
+  };
+  return {
+    colors: mockColors,
+    symbols: {
+      success: "+",
+      error: "x",
+      warning: "!",
+      info: "i",
+      bullet: "-",
+      clock: "T",
+      folder: "D",
+      package: "P",
+      pointer: ">",
+      section: "#",
+      separator: "-",
+      border: "|",
+      topLeft: "+",
+      topRight: "+",
+      bottomLeft: "+",
+      bottomRight: "+",
+      leftT: "+",
+      rightT: "+"
+    },
+    write: vi.fn((text) => messages.push(`WRITE: ${text}`)),
+    info: vi.fn((msg) => messages.push(`INFO: ${msg}`)),
+    success: vi.fn((msg) => messages.push(`SUCCESS: ${msg}`)),
+    warn: vi.fn((msg) => messages.push(`WARN: ${msg}`)),
+    error: vi.fn((err) => messages.push(`ERROR: ${err instanceof Error ? err.message : err}`)),
+    debug: vi.fn((msg) => messages.push(`DEBUG: ${msg}`)),
+    spinner: vi.fn((msg) => {
+      messages.push(`SPINNER: ${msg}`);
+      return {
+        update: vi.fn((m) => messages.push(`SPINNER UPDATE: ${m}`)),
+        succeed: vi.fn((m) => messages.push(`SPINNER SUCCEED: ${m ?? msg}`)),
+        fail: vi.fn((m) => messages.push(`SPINNER FAIL: ${m ?? msg}`)),
+        stop: vi.fn()
+      };
+    }),
+    table: vi.fn((data) => messages.push(`TABLE: ${JSON.stringify(data)}`)),
+    json: vi.fn((data) => messages.push(`JSON: ${JSON.stringify(data)}`)),
+    newline: vi.fn(() => messages.push("")),
+    divider: vi.fn(() => messages.push("-".repeat(40))),
+    box: vi.fn((content, title) => {
+      if (title) {
+        messages.push(`+- ${title} -+`);
+      }
+      messages.push(content);
+      if (title) {
+        messages.push(`+${"-".repeat(title.length + 4)}+`);
+      }
+    }),
+    sideBox: vi.fn((options) => {
+      messages.push(`+- ${options.title} -+`);
+      if (options.summary) {
+        Object.entries(options.summary).forEach(([key, value]) => {
+          messages.push(`  ${key}: ${value}`);
+        });
+      }
+      if (options.sections) {
+        options.sections.forEach((section) => {
+          if (section.header) {
+            messages.push(`  ${section.header}:`);
+          }
+          section.items.forEach((item) => messages.push(`    ${item}`));
+        });
+      }
+      if (options.timing) {
+        messages.push(`  Timing: ${options.timing}ms`);
+      }
+      messages.push("+" + "-".repeat(options.title.length + 4) + "+");
+    }),
+    confirm: vi.fn(async () => true),
+    prompt: vi.fn(async () => "")
+  };
+}
+function createMockRuntime() {
+  const mockFS = {
+    readFile: vi.fn(async () => ""),
+    readFileBuffer: vi.fn(async () => new Uint8Array()),
+    writeFile: vi.fn(async () => {
+    }),
+    readdir: vi.fn(async () => []),
+    readdirWithStats: vi.fn(async () => []),
+    mkdir: vi.fn(async () => {
+    }),
+    rm: vi.fn(async () => {
+    }),
+    copy: vi.fn(async () => {
+    }),
+    move: vi.fn(async () => {
+    }),
+    glob: vi.fn(async () => []),
+    stat: vi.fn(async () => ({
+      isFile: () => false,
+      isDirectory: () => false,
+      size: 0,
+      mtime: Date.now(),
+      ctime: Date.now()
+    })),
+    exists: vi.fn(async () => false),
+    resolve: (path) => path,
+    relative: (path) => path,
+    join: (...segments) => segments.join("/"),
+    dirname: (path) => path.split("/").slice(0, -1).join("/"),
+    basename: (path) => path.split("/").pop() ?? "",
+    extname: (path) => {
+      const base = path.split("/").pop() ?? "";
+      const idx = base.lastIndexOf(".");
+      return idx > 0 ? base.slice(idx) : "";
+    }
+  };
+  const mockFetch = vi.fn(async () => new Response("mock"));
+  const mockEnv = vi.fn((_key) => void 0);
+  return {
+    fs: mockFS,
+    fetch: mockFetch,
+    env: mockEnv
+  };
+}
+function createMockEnvironmentAPI() {
+  return {
+    create: vi.fn(async () => ({
+      environmentId: "env_mock_1",
+      provider: "mock",
+      status: "ready",
+      createdAt: (/* @__PURE__ */ new Date()).toISOString(),
+      updatedAt: (/* @__PURE__ */ new Date()).toISOString()
+    })),
+    status: vi.fn(async (environmentId) => ({
+      environmentId,
+      status: "ready",
+      updatedAt: (/* @__PURE__ */ new Date()).toISOString()
+    })),
+    destroy: vi.fn(async () => {
+    }),
+    renewLease: vi.fn(async () => ({
+      leaseId: "lease_mock_1",
+      acquiredAt: (/* @__PURE__ */ new Date()).toISOString(),
+      expiresAt: new Date(Date.now() + 10 * 60 * 1e3).toISOString()
+    }))
+  };
+}
+function createMockWorkspaceAPI() {
+  return {
+    materialize: vi.fn(async () => ({
+      workspaceId: "ws_mock_1",
+      provider: "mock",
+      status: "ready",
+      rootPath: "/tmp/ws_mock_1",
+      createdAt: (/* @__PURE__ */ new Date()).toISOString(),
+      updatedAt: (/* @__PURE__ */ new Date()).toISOString()
+    })),
+    attach: vi.fn(async (request) => ({
+      workspaceId: request.workspaceId,
+      environmentId: request.environmentId,
+      mountPath: request.mountPath ?? "/workspace",
+      attachedAt: (/* @__PURE__ */ new Date()).toISOString()
+    })),
+    release: vi.fn(async () => {
+    }),
+    status: vi.fn(async (workspaceId) => ({
+      workspaceId,
+      status: "ready",
+      updatedAt: (/* @__PURE__ */ new Date()).toISOString()
+    }))
+  };
+}
+function createMockSnapshotAPI() {
+  return {
+    capture: vi.fn(async (request) => ({
+      snapshotId: request.snapshotId ?? "snap_mock_1",
+      provider: "mock",
+      status: "ready",
+      createdAt: (/* @__PURE__ */ new Date()).toISOString(),
+      updatedAt: (/* @__PURE__ */ new Date()).toISOString(),
+      workspaceId: request.workspaceId,
+      environmentId: request.environmentId
+    })),
+    restore: vi.fn(async (request) => ({
+      snapshotId: request.snapshotId,
+      restoredAt: (/* @__PURE__ */ new Date()).toISOString(),
+      workspaceId: request.workspaceId,
+      environmentId: request.environmentId,
+      targetPath: request.targetPath
+    })),
+    status: vi.fn(async (snapshotId) => ({
+      snapshotId,
+      status: "ready",
+      updatedAt: (/* @__PURE__ */ new Date()).toISOString()
+    })),
+    delete: vi.fn(async () => {
+    }),
+    gc: vi.fn(async (request) => ({
+      scanned: 0,
+      deleted: 0,
+      dryRun: request?.dryRun ?? false
+    }))
+  };
+}
+function createInfraApiMocks() {
+  return {
+    environment: createMockEnvironmentAPI(),
+    workspace: createMockWorkspaceAPI(),
+    snapshot: createMockSnapshotAPI()
+  };
+}
+function createMockPluginAPI() {
+  const infra = createInfraApiMocks();
+  return {
+    lifecycle: {
+      onCleanup: vi.fn()
+    },
+    state: {
+      get: vi.fn(async () => void 0),
+      set: vi.fn(async () => {
+      }),
+      delete: vi.fn(async () => {
+      }),
+      has: vi.fn(async () => false),
+      getMany: vi.fn(async () => /* @__PURE__ */ new Map()),
+      setMany: vi.fn(async () => {
+      })
+    },
+    artifacts: {
+      write: vi.fn(async () => "/mock/path"),
+      list: vi.fn(async () => []),
+      read: vi.fn(async () => ""),
+      readBuffer: vi.fn(async () => new Uint8Array()),
+      exists: vi.fn(async () => false),
+      path: vi.fn(() => "/mock/path")
+    },
+    shell: {
+      exec: vi.fn(async () => ({ code: 0, stdout: "", stderr: "", ok: true }))
+    },
+    events: {
+      emit: vi.fn(async () => {
+      })
+    },
+    invoke: {
+      call: vi.fn(async (_pluginId, _input, _options) => void 0)
+    },
+    workflows: {
+      run: vi.fn(async () => "mock-run-id"),
+      wait: vi.fn(async () => void 0),
+      status: vi.fn(async () => null),
+      cancel: vi.fn(async () => {
+      }),
+      list: vi.fn(async () => [])
+    },
+    jobs: {
+      submit: vi.fn(async () => "mock-job-id"),
+      schedule: vi.fn(async () => "mock-scheduled-job-id"),
+      wait: vi.fn(async () => void 0),
+      status: vi.fn(async () => null),
+      cancel: vi.fn(async () => false),
+      list: vi.fn(async () => [])
+    },
+    cron: {
+      register: vi.fn(async () => {
+      }),
+      unregister: vi.fn(async () => {
+      }),
+      list: vi.fn(async () => []),
+      pause: vi.fn(async () => {
+      }),
+      resume: vi.fn(async () => {
+      }),
+      trigger: vi.fn(async () => {
+      })
+    },
+    environment: infra.environment,
+    workspace: infra.workspace,
+    snapshot: infra.snapshot
+  };
+}
+var createMockPlatformApi = createMockPluginAPI;
+function createMockPluginContextV3(options = {}) {
+  return createTestContext(options);
+}
+function createTestContext(options = {}) {
+  const {
+    pluginId = "test-plugin",
+    pluginVersion = "0.0.0",
+    host = "cli",
+    hostContext,
+    config,
+    cwd = process.cwd(),
+    outdir,
+    tenantId,
+    signal,
+    platform: platformOverrides,
+    ui: uiOverrides,
+    syncSingleton = true
+  } = options;
+  const resolvedOutdir = outdir ?? `${cwd}/.kb/output`;
+  const defaultHostContext = hostContext ?? (() => {
+    switch (host) {
+      case "cli":
+        return { host: "cli", argv: ["test"], flags: {} };
+      case "rest":
+        return {
+          host: "rest",
+          method: "GET",
+          path: "/test",
+          requestId: "test-req-001",
+          traceId: "test-trace-001"
+        };
+      case "workflow":
+        return { host: "workflow", workflowId: "test-wf", runId: "test-run", stepId: "test-step" };
+      case "webhook":
+        return { host: "webhook", event: "test:event" };
+    }
+  })();
+  const defaultLogger = mockLogger();
+  const defaultLLM = mockLLM();
+  const defaultCache = mockCache();
+  const defaultStorage = mockStorage();
+  const defaultPlatform = {
+    logger: defaultLogger,
+    llm: defaultLLM,
+    embeddings: {
+      embed: vi.fn(async () => []),
+      embedBatch: vi.fn(async () => [[]]),
+      dimensions: 1536,
+      getDimensions: vi.fn(async () => 1536)
+    },
+    vectorStore: {
+      search: vi.fn(async () => []),
+      upsert: vi.fn(async () => {
+      }),
+      delete: vi.fn(async () => {
+      }),
+      count: vi.fn(async () => 0)
+    },
+    cache: defaultCache,
+    storage: defaultStorage,
+    analytics: {
+      track: vi.fn(async () => {
+      }),
+      identify: vi.fn(async () => {
+      }),
+      flush: vi.fn(async () => {
+      })
+    },
+    eventBus: {
+      publish: vi.fn(async () => {
+      }),
+      subscribe: vi.fn(() => () => {
+      })
+    },
+    logs: {
+      query: vi.fn(async () => ({ logs: [], total: 0, hasMore: false, source: "buffer" })),
+      getById: vi.fn(async () => null),
+      search: vi.fn(async () => ({ logs: [], total: 0, hasMore: false })),
+      subscribe: vi.fn(() => () => {
+      }),
+      getStats: vi.fn(async () => ({})),
+      getCapabilities: vi.fn(() => ({ hasBuffer: false, hasPersistence: false, hasSearch: false, hasStreaming: false }))
+    }
+  };
+  const finalPlatform = {
+    ...defaultPlatform,
+    ...platformOverrides
+  };
+  let cleanupFn = () => {
+  };
+  if (syncSingleton) {
+    const result = setupTestPlatform({
+      llm: finalPlatform.llm,
+      cache: finalPlatform.cache,
+      storage: finalPlatform.storage,
+      logger: finalPlatform.logger,
+      analytics: finalPlatform.analytics,
+      embeddings: finalPlatform.embeddings,
+      vectorStore: finalPlatform.vectorStore,
+      eventBus: finalPlatform.eventBus
+    });
+    cleanupFn = result.cleanup;
+  }
+  const defaultUI = createMockUI();
+  const finalUI = {
+    ...defaultUI,
+    ...uiOverrides
+  };
+  const ctx = {
+    host,
+    requestId: "test-trace:test-span",
+    pluginId,
+    pluginVersion,
+    tenantId,
+    cwd,
+    outdir: resolvedOutdir,
+    config,
+    signal,
+    trace: createMockTrace(),
+    hostContext: defaultHostContext,
+    ui: finalUI,
+    platform: finalPlatform,
+    runtime: createMockRuntime(),
+    api: createMockPluginAPI()
+  };
+  return { ctx, cleanup: cleanupFn };
+}
+
+// src/test-command.ts
+async function testCommand(handler, options = {}) {
+  const {
+    flags,
+    argv = [],
+    query,
+    body,
+    params,
+    input: rawInput,
+    host = "cli",
+    config,
+    cwd,
+    tenantId,
+    signal,
+    platform: platform2,
+    ui,
+    syncSingleton = true
+  } = options;
+  const ctxOptions = {
+    host,
+    config,
+    cwd,
+    tenantId,
+    signal,
+    platform: platform2,
+    ui,
+    syncSingleton
+  };
+  const { ctx, cleanup } = createTestContext(ctxOptions);
+  let input;
+  if (rawInput !== void 0) {
+    input = rawInput;
+  } else if (host === "rest") {
+    input = {
+      ...query !== void 0 ? { query } : {},
+      ...body !== void 0 ? { body } : {},
+      ...params !== void 0 ? { params } : {}
+    };
+  } else {
+    input = { flags: flags ?? {}, argv };
+  }
+  let raw;
+  try {
+    raw = await handler.execute(ctx, input);
+  } finally {
+    await handler.cleanup?.();
+  }
+  let exitCode = 0;
+  let result;
+  let meta;
+  if (raw != null && typeof raw === "object" && "exitCode" in raw) {
+    const cmdResult = raw;
+    exitCode = cmdResult.exitCode;
+    result = cmdResult.result;
+    meta = cmdResult.meta;
+  } else if (raw === void 0 || raw === null) {
+    exitCode = 0;
+    result = void 0;
+    meta = void 0;
+  } else {
+    exitCode = 0;
+    result = raw;
+    meta = void 0;
+  }
+  return {
+    exitCode,
+    result,
+    meta,
+    raw,
+    ui: ctx.ui,
+    ctx,
+    cleanup
+  };
+}
+
+export { createInfraApiMocks, createMockEnvironmentAPI, createMockPlatformApi, createMockPluginAPI, createMockPluginContextV3, createMockRuntime, createMockSnapshotAPI, createMockTrace, createMockUI, createMockWorkspaceAPI, createTestContext, mockCache, mockLLM, mockLogger, mockStorage, setupTestPlatform, testCommand };
+//# sourceMappingURL=index.js.map
+//# sourceMappingURL=index.js.map