llmist 1.2.0 → 1.3.1

package/dist/{chunk-LELPPETT.js → chunk-TFIKR2RK.js}

@@ -9,7 +9,7 @@ import {
   init_constants,
   init_gadget,
   init_logger
-} from "./chunk-KORMY3CD.js";
+} from "./chunk-RZTAKIDE.js";
 
 // src/gadgets/validation.ts
 function validateAndApplyDefaults(schema, params) {
@@ -917,6 +917,437 @@ function mockGadget() {
   return new MockGadgetBuilder();
 }
 
+// src/testing/stream-helpers.ts
+function createTestStream(chunks) {
+  return async function* () {
+    for (const chunk of chunks) {
+      yield chunk;
+    }
+  }();
+}
+function createTextStream(text, options) {
+  return async function* () {
+    if (options?.delayMs) {
+      await sleep2(options.delayMs);
+    }
+    const chunkSize = options?.chunkSize ?? text.length;
+    const chunks = [];
+    for (let i = 0; i < text.length; i += chunkSize) {
+      chunks.push(text.slice(i, i + chunkSize));
+    }
+    for (let i = 0; i < chunks.length; i++) {
+      const isLast = i === chunks.length - 1;
+      const chunk = { text: chunks[i] };
+      if (isLast) {
+        chunk.finishReason = options?.finishReason ?? "stop";
+        const inputTokens = Math.ceil(text.length / 4);
+        const outputTokens = Math.ceil(text.length / 4);
+        chunk.usage = options?.usage ?? {
+          inputTokens,
+          outputTokens,
+          totalTokens: inputTokens + outputTokens
+        };
+      }
+      yield chunk;
+      if (options?.chunkDelayMs && !isLast) {
+        await sleep2(options.chunkDelayMs);
+      }
+    }
+  }();
+}
+async function collectStream(stream) {
+  const chunks = [];
+  for await (const chunk of stream) {
+    chunks.push(chunk);
+  }
+  return chunks;
+}
+async function collectStreamText(stream) {
+  let text = "";
+  for await (const chunk of stream) {
+    text += chunk.text ?? "";
+  }
+  return text;
+}
+async function getStreamFinalChunk(stream) {
+  let lastChunk;
+  for await (const chunk of stream) {
+    lastChunk = chunk;
+  }
+  return lastChunk;
+}
+function createEmptyStream() {
+  return async function* () {
+  }();
+}
+function createErrorStream(chunksBeforeError, error) {
+  return async function* () {
+    for (const chunk of chunksBeforeError) {
+      yield chunk;
+    }
+    throw error;
+  }();
+}
+function sleep2(ms) {
+  return new Promise((resolve) => setTimeout(resolve, ms));
+}
+
+// src/testing/conversation-fixtures.ts
+function createConversation(turnCount, options) {
+  const messages = [];
+  const userPrefix = options?.userPrefix ?? "User message";
+  const assistantPrefix = options?.assistantPrefix ?? "Assistant response";
+  const contentLength = options?.contentLength ?? 100;
+  for (let i = 0; i < turnCount; i++) {
+    const padding = " ".repeat(Math.max(0, contentLength - 30));
+    messages.push({
+      role: "user",
+      content: `${userPrefix} ${i + 1}: This is turn ${i + 1} of the conversation.${padding}`
+    });
+    messages.push({
+      role: "assistant",
+      content: `${assistantPrefix} ${i + 1}: I acknowledge turn ${i + 1}.${padding}`
+    });
+  }
+  return messages;
+}
+function createConversationWithGadgets(turnCount, gadgetCallsPerTurn = 1, options) {
+  const messages = [];
+  const gadgetNames = options?.gadgetNames ?? ["search", "calculate", "read"];
+  const contentLength = options?.contentLength ?? 50;
+  let gadgetIndex = 0;
+  for (let turn = 0; turn < turnCount; turn++) {
+    messages.push({
+      role: "user",
+      content: `User request ${turn + 1}${"x".repeat(contentLength)}`
+    });
+    for (let g = 0; g < gadgetCallsPerTurn; g++) {
+      const gadgetName = gadgetNames[gadgetIndex % gadgetNames.length];
+      gadgetIndex++;
+      messages.push({
+        role: "assistant",
+        content: `!!!GADGET_START:${gadgetName}
+!!!ARG:query
+test query ${turn}-${g}
+!!!GADGET_END`
+      });
+      messages.push({
+        role: "user",
+        content: `Result: Gadget ${gadgetName} returned result for query ${turn}-${g}`
+      });
+    }
+    messages.push({
+      role: "assistant",
+      content: `Final response for turn ${turn + 1}${"y".repeat(contentLength)}`
+    });
+  }
+  return messages;
+}
+function estimateTokens(messages) {
+  return Math.ceil(
+    messages.reduce((sum, msg) => sum + (msg.content?.length ?? 0), 0) / 4
+  );
+}
+function createUserMessage(content) {
+  return { role: "user", content };
+}
+function createAssistantMessage(content) {
+  return { role: "assistant", content };
+}
+function createSystemMessage(content) {
+  return { role: "system", content };
+}
+function createMinimalConversation() {
+  return [
+    { role: "user", content: "Hello" },
+    { role: "assistant", content: "Hi there!" }
+  ];
+}
+function createLargeConversation(targetTokens, options) {
+  const tokensPerTurn = options?.tokensPerTurn ?? 200;
+  const turnsNeeded = Math.ceil(targetTokens / tokensPerTurn);
+  const charsPerMessage = Math.floor(tokensPerTurn * 4 / 2);
+  return createConversation(turnsNeeded, {
+    contentLength: charsPerMessage
+  });
+}
+
+// src/testing/mock-conversation.ts
+var MockConversationManager = class {
+  history;
+  baseMessages;
+  replacementHistory;
+  replaceHistoryCallCount = 0;
+  addedMessages = [];
+  constructor(history = [], baseMessages = []) {
+    this.history = [...history];
+    this.baseMessages = [...baseMessages];
+  }
+  addUserMessage(content) {
+    const msg = { role: "user", content };
+    this.history.push(msg);
+    this.addedMessages.push(msg);
+  }
+  addAssistantMessage(content) {
+    const msg = { role: "assistant", content };
+    this.history.push(msg);
+    this.addedMessages.push(msg);
+  }
+  addGadgetCall(gadgetName, parameters, result) {
+    const assistantMsg = {
+      role: "assistant",
+      content: `!!!GADGET_START:${gadgetName}
+${JSON.stringify(parameters)}
+!!!GADGET_END`
+    };
+    const resultMsg = {
+      role: "user",
+      content: `Result: ${result}`
+    };
+    this.history.push(assistantMsg);
+    this.history.push(resultMsg);
+    this.addedMessages.push(assistantMsg);
+    this.addedMessages.push(resultMsg);
+  }
+  getMessages() {
+    return [...this.baseMessages, ...this.history];
+  }
+  getHistoryMessages() {
+    return [...this.history];
+  }
+  getBaseMessages() {
+    return [...this.baseMessages];
+  }
+  replaceHistory(newHistory) {
+    this.replacementHistory = [...newHistory];
+    this.history = [...newHistory];
+    this.replaceHistoryCallCount++;
+  }
+  // ============================================
+  // Test Helper Methods
+  // ============================================
+  /**
+   * Check if replaceHistory was called.
+   */
+  wasReplaceHistoryCalled() {
+    return this.replaceHistoryCallCount > 0;
+  }
+  /**
+   * Get the number of times replaceHistory was called.
+   */
+  getReplaceHistoryCallCount() {
+    return this.replaceHistoryCallCount;
+  }
+  /**
+   * Get the most recent history passed to replaceHistory.
+   * Returns undefined if replaceHistory was never called.
+   */
+  getReplacementHistory() {
+    return this.replacementHistory;
+  }
+  /**
+   * Get all messages that were added via add* methods.
+   */
+  getAddedMessages() {
+    return [...this.addedMessages];
+  }
+  /**
+   * Reset all tracking state while preserving the conversation.
+   */
+  resetTracking() {
+    this.replacementHistory = void 0;
+    this.replaceHistoryCallCount = 0;
+    this.addedMessages = [];
+  }
+  /**
+   * Completely reset the mock to initial state.
+   * Note: baseMessages cannot be changed after construction.
+   */
+  reset(history = []) {
+    this.history = [...history];
+    this.resetTracking();
+  }
+  /**
+   * Set the history directly (for test setup).
+   */
+  setHistory(messages) {
+    this.history = [...messages];
+  }
+  /**
+   * Get the current history length.
+   */
+  getHistoryLength() {
+    return this.history.length;
+  }
+  /**
+   * Get total message count (base + history).
+   */
+  getTotalMessageCount() {
+    return this.baseMessages.length + this.history.length;
+  }
+};
+function createMockConversationManager(turnCount, baseMessages = []) {
+  const history = [];
+  for (let i = 0; i < turnCount; i++) {
+    history.push({
+      role: "user",
+      content: `User message ${i + 1}: This is turn ${i + 1} of the conversation.`
+    });
+    history.push({
+      role: "assistant",
+      content: `Assistant response ${i + 1}: I acknowledge turn ${i + 1}.`
+    });
+  }
+  return new MockConversationManager(history, baseMessages);
+}
+
+// src/testing/cli-helpers.ts
+import { PassThrough, Readable, Writable } from "node:stream";
+function createTestEnvironment(options = {}) {
+  const stdin = createMockReadable(options.stdin);
+  const stdout = new PassThrough();
+  const stderr = new PassThrough();
+  let exitCode;
+  return {
+    stdin,
+    stdout,
+    stderr,
+    isTTY: options.isTTY ?? false,
+    argv: options.argv ?? ["node", "llmist"],
+    env: { ...filterDefinedEnv(process.env), ...options.env },
+    get exitCode() {
+      return exitCode;
+    },
+    setExitCode: (code) => {
+      exitCode = code;
+    }
+  };
+}
+function createMockReadable(input) {
+  if (!input) {
+    const stream2 = new Readable({ read() {
+    } });
+    stream2.push(null);
+    return stream2;
+  }
+  const content = Array.isArray(input) ? `${input.join("\n")}
+` : input;
+  const stream = new Readable({ read() {
+  } });
+  stream.push(content);
+  stream.push(null);
+  return stream;
+}
+function createMockWritable() {
+  const chunks = [];
+  const stream = new Writable({
+    write(chunk, _encoding, callback) {
+      chunks.push(Buffer.from(chunk));
+      callback();
+    }
+  });
+  stream.getData = () => Buffer.concat(chunks).toString("utf8");
+  return stream;
+}
+async function collectOutput(stream, timeout = 5e3) {
+  return new Promise((resolve, reject) => {
+    const chunks = [];
+    const timeoutId = setTimeout(() => {
+      resolve(Buffer.concat(chunks).toString("utf8"));
+    }, timeout);
+    stream.on("data", (chunk) => {
+      chunks.push(Buffer.from(chunk));
+    });
+    stream.on("end", () => {
+      clearTimeout(timeoutId);
+      resolve(Buffer.concat(chunks).toString("utf8"));
+    });
+    stream.on("error", (err) => {
+      clearTimeout(timeoutId);
+      reject(err);
+    });
+  });
+}
+function getBufferedOutput(stream) {
+  const chunks = [];
+  for (; ; ) {
+    const chunk = stream.read();
+    if (chunk === null) break;
+    chunks.push(chunk);
+  }
+  return Buffer.concat(chunks).toString("utf8");
+}
+function createMockPrompt(responses) {
+  let index = 0;
+  return async (_question) => {
+    if (index >= responses.length) {
+      throw new Error(`Mock prompt exhausted: no response for question ${index + 1}`);
+    }
+    return responses[index++];
+  };
+}
+var MockPromptRecorder = class {
+  responses;
+  index = 0;
+  questions = [];
+  constructor(responses) {
+    this.responses = responses;
+  }
+  /**
+   * The prompt function to use in tests.
+   */
+  prompt = async (question) => {
+    this.questions.push(question);
+    if (this.index >= this.responses.length) {
+      throw new Error(`Mock prompt exhausted after ${this.index} questions`);
+    }
+    return this.responses[this.index++];
+  };
+  /**
+   * Get all questions that were asked.
+   */
+  getQuestions() {
+    return [...this.questions];
+  }
+  /**
+   * Get the number of questions asked.
+   */
+  getQuestionCount() {
+    return this.questions.length;
+  }
+  /**
+   * Reset the recorder state.
+   */
+  reset(newResponses) {
+    this.index = 0;
+    this.questions = [];
+    if (newResponses) {
+      this.responses = newResponses;
+    }
+  }
+};
+async function waitFor(condition, timeout = 5e3, interval = 50) {
+  const startTime = Date.now();
+  while (!condition()) {
+    if (Date.now() - startTime > timeout) {
+      throw new Error(`waitFor timed out after ${timeout}ms`);
+    }
+    await sleep3(interval);
+  }
+}
+function sleep3(ms) {
+  return new Promise((resolve) => setTimeout(resolve, ms));
+}
+function filterDefinedEnv(env) {
+  const result = {};
+  for (const [key, value] of Object.entries(env)) {
+    if (value !== void 0) {
+      result[key] = value;
+    }
+  }
+  return result;
+}
+
 export {
   validateAndApplyDefaults,
   validateGadgetParams,
@@ -933,6 +1364,31 @@ export {
   createMockClient,
   createMockGadget,
   MockGadgetBuilder,
-  mockGadget
+  mockGadget,
+  createTestStream,
+  createTextStream,
+  collectStream,
+  collectStreamText,
+  getStreamFinalChunk,
+  createEmptyStream,
+  createErrorStream,
+  createConversation,
+  createConversationWithGadgets,
+  estimateTokens,
+  createUserMessage,
+  createAssistantMessage,
+  createSystemMessage,
+  createMinimalConversation,
+  createLargeConversation,
+  MockConversationManager,
+  createMockConversationManager,
+  createTestEnvironment,
+  createMockReadable,
+  createMockWritable,
+  collectOutput,
+  getBufferedOutput,
+  createMockPrompt,
+  MockPromptRecorder,
+  waitFor
 };
-//# sourceMappingURL=chunk-LELPPETT.js.map
+//# sourceMappingURL=chunk-TFIKR2RK.js.map