@forwardimpact/libharness 0.1.20 → 1.0.0

package/src/mock/resource-index.js

@@ -1,95 +0,0 @@
-import { common, tool } from "@forwardimpact/libtype";
-
-/**
- * Creates a mock resource index with common test data
- * @param {object} options - Setup options
- * @returns {object} Mock resource index
- */
-export function createMockResourceIndex(options = {}) {
-  const resources = new Map();
-
-  const index = {
-    resources,
-
-    async get(identifiers, _actor) {
-      if (!identifiers || identifiers.length === 0) return [];
-      return identifiers
-        .map((id) => {
-          const key = typeof id === "string" ? id : id.toString?.() || id.name;
-          return resources.get(key);
-        })
-        .filter(Boolean);
-    },
-
-    put(resource) {
-      const key = resource.id?.toString?.() || resource.id?.name;
-      if (key) resources.set(key, resource);
-    },
-
-    async has(id) {
-      const key = typeof id === "string" ? id : id.toString?.();
-      return resources.has(key);
-    },
-
-    /**
-     * Sets up default test resources
-     * @param {object} setupOptions - Setup options
-     * @param {string[]} [setupOptions.tools] - Tool names to seed
-     * @param {string} [setupOptions.conversationId] - Conversation ID
-     */
-    setupDefaults(setupOptions = {}) {
-      const { tools = [], conversationId = "test-conversation" } = setupOptions;
-
-      resources.set(
-        conversationId,
-        common.Conversation.fromObject({
-          id: { name: conversationId },
-        }),
-      );
-
-      for (const name of tools) {
-        resources.set(
-          `tool.ToolFunction.${name}`,
-          tool.ToolFunction.fromObject({
-            id: { name, tokens: 20 },
-            name,
-            description: `${name} tool`,
-          }),
-        );
-      }
-    },
-
-    /**
-     * Adds a message resource
-     * @param {object} msg - Message to add
-     */
-    addMessage(msg) {
-      const id =
-        msg.id?.type && msg.id?.toString
-          ? msg.id.toString()
-          : msg.id?.name || String(msg.id);
-      resources.set(id, msg);
-    },
-
-    /**
-     * Find resources by prefix
-     * @param {string} prefix - Prefix to search for
-     * @returns {Promise<string[]>} List of matching keys
-     */
-    async findByPrefix(prefix) {
-      const keys = [];
-      for (const key of resources.keys()) {
-        if (key.startsWith(prefix)) {
-          keys.push(key);
-        }
-      }
-      return keys;
-    },
-  };
-
-  if (options.tools || options.conversationId) {
-    index.setupDefaults(options);
-  }
-
-  return index;
-}

package/src/mock/service-callbacks.js

@@ -1,39 +0,0 @@
-/**
- * Creates a mock service callbacks object for agent testing
- * @param {object} overrides - Method overrides per service
- * @returns {object} Service callbacks object
- */
-export function createMockServiceCallbacks(overrides = {}) {
-  return {
-    memory: {
-      append: async () => ({}),
-      get: async () => ({
-        messages: [{ role: "system", content: "You are an assistant" }],
-        tools: [],
-      }),
-      ...overrides.memory,
-    },
-    llm: {
-      createCompletions: async () => ({
-        choices: [
-          {
-            message: {
-              role: "assistant",
-              content: "Test response",
-              tool_calls: [],
-            },
-          },
-        ],
-      }),
-      ...overrides.llm,
-    },
-    tool: {
-      call: async () => ({
-        role: "tool",
-        content: "Tool result",
-      }),
-      ...overrides.tool,
-    },
-    ...overrides,
-  };
-}

package/src/mock/services.js

@@ -1,79 +0,0 @@
-/**
- * Mock service utilities for testing
- */
-
-/**
- * Creates a mock vector service
- * @param {object} overrides - Properties to override in the mock
- * @returns {object} Mock vector service
- */
-export function mockVectorService(overrides = {}) {
-  return {
-    QueryItems: async (request, callback) => {
-      callback(null, { results: [], total: 0 });
-    },
-    close: () => {},
-    ...overrides,
-  };
-}
-
-/**
- * Creates a mock history service
- * @param {object} overrides - Properties to override in the mock
- * @returns {object} Mock history service
- */
-export function mockHistoryService(overrides = {}) {
-  return {
-    GetHistory: async (request, callback) => {
-      callback(null, { messages: [] });
-    },
-    UpdateHistory: async (request, callback) => {
-      callback(null, {});
-    },
-    close: () => {},
-    ...overrides,
-  };
-}
-
-/**
- * Creates a mock LLM service
- * @param {object} overrides - Properties to override in the mock
- * @returns {object} Mock LLM service
- */
-export function mockLlmService(overrides = {}) {
-  return {
-    CreateCompletions: async (request, callback) => {
-      callback(null, {
-        choices: [
-          {
-            index: 0,
-            message: { role: "assistant", content: "Test response" },
-            finish_reason: "stop",
-          },
-        ],
-      });
-    },
-    CreateEmbeddings: async (request, callback) => {
-      callback(null, {
-        data: [{ index: 0, embedding: [0.1, 0.2, 0.3] }],
-      });
-    },
-    close: () => {},
-    ...overrides,
-  };
-}
-
-/**
- * Creates a mock text service
- * @param {object} overrides - Properties to override in the mock
- * @returns {object} Mock text service
- */
-export function mockTextService(overrides = {}) {
-  return {
-    GetChunks: async (request, callback) => {
-      callback(null, { chunks: {} });
-    },
-    close: () => {},
-    ...overrides,
-  };
-}

package/src/mock/spy.js

@@ -1,44 +0,0 @@
-/**
- * Portable mock function helper. Replaces `mock.fn` from `node:test` so the
- * test suite can run under either node:test or bun:test.
- *
- * Shape matches node:test's `mock.fn` to keep call-inspection sites
- * (`fn.mock.calls[0].arguments`, `fn.mock.callCount()`, `fn.mock.resetCalls()`)
- * unchanged across the codebase.
- *
- * @template T
- * @param {(...args: any[]) => T} [impl] - Initial implementation.
- * @returns {((...args: any[]) => T) & { mock: { calls: Array<{arguments: any[], result?: T, error?: unknown, this: unknown}>, callCount: () => number, resetCalls: () => void, mockImplementation: (newImpl: (...args: any[]) => T) => void } }}
- */
-export function spy(impl) {
-  let _impl = impl;
-  const calls = [];
-  const fn = function (...args) {
-    const rec = { arguments: args, this: this };
-    if (!_impl) {
-      calls.push(rec);
-      return undefined;
-    }
-    try {
-      const result = _impl.apply(this, args);
-      rec.result = result;
-      calls.push(rec);
-      return result;
-    } catch (err) {
-      rec.error = err;
-      calls.push(rec);
-      throw err;
-    }
-  };
-  fn.mock = {
-    calls,
-    callCount: () => calls.length,
-    resetCalls: () => {
-      calls.length = 0;
-    },
-    mockImplementation: (newImpl) => {
-      _impl = newImpl;
-    },
-  };
-  return fn;
-}

package/src/mock/storage.js

@@ -1,118 +0,0 @@
-import { spy } from "./spy.js";
-/**
- * Creates a mock storage instance with tracking
- * @param {object} overrides - Method overrides
- * @returns {object} Mock storage with data tracking
- */
-export function createMockStorage(overrides = {}) {
-  const data = new Map();
-
-  return {
-    data,
-    exists: spy((key) => Promise.resolve(data.has(key))),
-    get: spy((key) => {
-      const value = data.get(key);
-      if (!value) return Promise.reject(new Error("Not found"));
-
-      if (key.endsWith(".json")) {
-        return Promise.resolve(value ? JSON.parse(value) : {});
-      }
-      if (key.endsWith(".jsonl")) {
-        const lines = value.split("\n").filter(Boolean);
-        return Promise.resolve(lines.map((line) => JSON.parse(line)));
-      }
-      return Promise.resolve(value);
-    }),
-    put: spy((key, value) => {
-      data.set(key, value);
-      return Promise.resolve();
-    }),
-    append: spy((key, value) => {
-      const existing = data.get(key) || "";
-      data.set(key, existing ? `${existing}\n${value}` : value);
-      return Promise.resolve();
-    }),
-    delete: spy((key) => {
-      data.delete(key);
-      return Promise.resolve();
-    }),
-    findByPrefix: spy(() => Promise.resolve([])),
-    ...overrides,
-  };
-}
-
-/**
- * MockStorage class for OOP-style usage
- */
-export class MockStorage {
-  /**
-   * Creates a new MockStorage instance
-   */
-  constructor() {
-    this.data = new Map();
-  }
-
-  /**
-   * Gets a value by key
-   * @param {string} key - The storage key
-   * @returns {Promise<*>} The stored value
-   */
-  async get(key) {
-    const value = this.data.get(key);
-    if (!value) throw new Error("Not found");
-
-    if (key.endsWith(".jsonl")) {
-      return value.split("\n").map((line) => JSON.parse(line));
-    }
-    return value;
-  }
-
-  /**
-   * Stores a value by key
-   * @param {string} key - The storage key
-   * @param {*} value - The value to store
-   * @returns {Promise<void>}
-   */
-  async put(key, value) {
-    this.data.set(key, value);
-  }
-
-  /**
-   * Alias for put - stores a value by key
-   * @param {string} key - The storage key
-   * @param {*} value - The value to store
-   * @returns {Promise<void>}
-   */
-  async set(key, value) {
-    this.data.set(key, value);
-  }
-
-  /**
-   * Appends a value to an existing key
-   * @param {string} key - The storage key
-   * @param {string} value - The value to append
-   * @returns {Promise<void>}
-   */
-  async append(key, value) {
-    const existing = this.data.get(key) || "";
-    this.data.set(key, existing ? `${existing}\n${value}` : value);
-  }
-
-  /**
-   * Checks if a key exists
-   * @param {string} key - The storage key
-   * @returns {Promise<boolean>} True if key exists
-   */
-  async exists(key) {
-    return this.data.has(key);
-  }
-
-  /**
-   * Deletes a value by key
-   * @param {string} key - The storage key
-   * @returns {Promise<void>}
-   */
-  async delete(key) {
-    this.data.delete(key);
-  }
-}