@tyvm/knowhow 0.0.158 → 0.0.160

package/tests/services/ToolsService.setFunction.test.ts

@@ -1,68 +0,0 @@
-import { ToolsService } from "../../src/services/Tools";
-
-describe("ToolsService.setFunction bug with multiple registrations", () => {
-  let toolsService: ToolsService;
-
-  beforeEach(() => {
-    toolsService = new ToolsService();
-  });
-
-  it("should update function when setFunction is called multiple times with different implementations", () => {
-    // Simulate first TokenCompressor registering expandTokens
-    const storage1 = new Map();
-    storage1.set("key1", "data1");
-    
-    const expandTokens1 = ({ key }: { key: string }) => {
-      const data = storage1.get(key);
-      if (!data) throw new Error(`No data found for key: ${key}`);
-      return data;
-    };
-
-    // Register the tool definition
-    toolsService.addTools([
-      {
-        type: "function",
-        function: {
-          name: "expandTokens",
-          description: "Retrieve compressed data",
-          parameters: {
-            type: "object",
-            properties: {
-              key: { type: "string", description: "The key" },
-            },
-            required: ["key"],
-          },
-        },
-      },
-    ]);
-
-    // First registration
-    toolsService.setFunction("expandTokens", expandTokens1);
-    
-    // Test first function works
-    const func1 = toolsService.getFunction("expandTokens");
-    expect(func1({ key: "key1" })).toBe("data1");
-
-    // Simulate second TokenCompressor registering expandTokens with NEW storage
-    const storage2 = new Map();
-    storage2.set("key2", "data2");
-    
-    const expandTokens2 = ({ key }: { key: string }) => {
-      const data = storage2.get(key);
-      if (!data) throw new Error(`No data found for key: ${key}`);
-      return data;
-    };
-
-    // Second registration (simulating AgentModule creating new TokenCompressor)
-    toolsService.setFunction("expandTokens", expandTokens2);
-    
-    // Test second function
-    const func2 = toolsService.getFunction("expandTokens");
-    
-    // After fix: Should NOT work with old storage anymore
-    expect(() => func2({ key: "key1" })).toThrow("No data found for key: key1");
-    
-    // After fix: Should work with NEW storage
-    expect(func2({ key: "key2" })).toBe("data2");
-  });
-});

package/tests/services/WorkerReloadConfig.test.ts

@@ -1,141 +0,0 @@
-/**
- * Tests for the worker reloadConfig message handler.
- *
- * We test the core logic in isolation — simulating the "reloadConfig" message
- * arriving on the WebSocket and verifying that MCPs are torn down and
- * re-connected, and that the tool list is rebuilt from fresh config.
- */
-
-import { McpService } from "../../src/services/Mcp";
-import { ToolsService } from "../../src/services/Tools";
-
-// ---------------------------------------------------------------------------
-// Helpers: build the same reload logic that lives in worker.ts so we can
-// test it in isolation without spinning up a real WebSocket server.
-// ---------------------------------------------------------------------------
-
-async function simulateReloadConfig(
-  Mcp: McpService,
-  Tools: ToolsService,
-  mcpServer: { withTools: (tools: unknown[]) => void },
-  getConfig: () => Promise<{ worker?: { allowedTools?: string[] } }>,
-  toolsToUseRef: { value: unknown[] }
-) {
-  // This mirrors the handler in worker.ts
-  const freshConfig = await getConfig();
-  await Mcp.closeAll();
-  await Mcp.connectToConfigured(Tools);
-  const allowedToolNames =
-    freshConfig.worker?.allowedTools ?? Tools.getToolNames();
-  toolsToUseRef.value = Tools.getToolsByNames(allowedToolNames);
-  mcpServer.withTools(toolsToUseRef.value);
-}
-
-// ---------------------------------------------------------------------------
-// Tests
-// ---------------------------------------------------------------------------
-
-describe("Worker reloadConfig handler", () => {
-  let Mcp: McpService;
-  let Tools: ToolsService;
-  let mcpServer: { withTools: jest.Mock };
-  let toolsToUseRef: { value: unknown[] };
-
-  beforeEach(() => {
-    Mcp = new McpService();
-    Tools = new ToolsService();
-    mcpServer = { withTools: jest.fn() };
-    toolsToUseRef = { value: [] };
-
-    // Spy on MCP methods
-    jest.spyOn(Mcp, "closeAll").mockResolvedValue(undefined);
-    jest.spyOn(Mcp, "connectToConfigured").mockResolvedValue(undefined);
-  });
-
-  afterEach(() => {
-    jest.restoreAllMocks();
-  });
-
-  it("should call closeAll() to tear down existing MCP connections", async () => {
-    const getConfig = jest
-      .fn()
-      .mockResolvedValue({ worker: { allowedTools: [] } });
-
-    await simulateReloadConfig(Mcp, Tools, mcpServer, getConfig, toolsToUseRef);
-
-    expect(Mcp.closeAll).toHaveBeenCalledTimes(1);
-  });
-
-  it("should call connectToConfigured() to reconnect MCPs from fresh config", async () => {
-    const getConfig = jest
-      .fn()
-      .mockResolvedValue({ worker: { allowedTools: [] } });
-
-    await simulateReloadConfig(Mcp, Tools, mcpServer, getConfig, toolsToUseRef);
-
-    expect(Mcp.connectToConfigured).toHaveBeenCalledWith(Tools);
-  });
-
-  it("should rebuild the tool list from allowedTools in fresh config", async () => {
-    // Spy on getToolsByNames so we can track what names were requested
-    const toolsByNamesSpy = jest
-      .spyOn(Tools, "getToolsByNames")
-      .mockReturnValue([{ function: { name: "execCommand" } }] as ReturnType<ToolsService["getToolsByNames"]>);
-
-    const getConfig = jest
-      .fn()
-      .mockResolvedValue({ worker: { allowedTools: ["execCommand"] } });
-
-    await simulateReloadConfig(Mcp, Tools, mcpServer, getConfig, toolsToUseRef);
-
-    expect(toolsByNamesSpy).toHaveBeenCalledWith(["execCommand"]);
-    expect(toolsToUseRef.value).toHaveLength(1);
-  });
-
-  it("should fall back to all tool names when allowedTools is not set", async () => {
-    const allNames = ["execCommand", "readFile", "writeFileChunk"];
-    jest.spyOn(Tools, "getToolNames").mockReturnValue(allNames);
-    const toolsByNamesSpy = jest
-      .spyOn(Tools, "getToolsByNames")
-      .mockReturnValue([] as ReturnType<ToolsService["getToolsByNames"]>);
-
-    // Config has no worker.allowedTools
-    const getConfig = jest.fn().mockResolvedValue({});
-
-    await simulateReloadConfig(Mcp, Tools, mcpServer, getConfig, toolsToUseRef);
-
-    expect(toolsByNamesSpy).toHaveBeenCalledWith(allNames);
-  });
-
-  it("should call mcpServer.withTools() with the rebuilt tool list", async () => {
-    const fakeTools = [{ function: { name: "readFile" } }] as ReturnType<ToolsService["getToolsByNames"]>;
-    jest.spyOn(Tools, "getToolsByNames").mockReturnValue(fakeTools);
-
-    const getConfig = jest
-      .fn()
-      .mockResolvedValue({ worker: { allowedTools: ["readFile"] } });
-
-    await simulateReloadConfig(Mcp, Tools, mcpServer, getConfig, toolsToUseRef);
-
-    expect(mcpServer.withTools).toHaveBeenCalledWith(fakeTools);
-  });
-
-  it("should re-read the config on every reload (not use stale config)", async () => {
-    const getConfig = jest
-      .fn()
-      .mockResolvedValueOnce({ worker: { allowedTools: ["execCommand"] } })
-      .mockResolvedValueOnce({ worker: { allowedTools: ["readFile", "writeFileChunk"] } });
-
-    jest.spyOn(Tools, "getToolsByNames").mockReturnValue([]);
-
-    // First reload
-    await simulateReloadConfig(Mcp, Tools, mcpServer, getConfig, toolsToUseRef);
-    // Second reload
-    await simulateReloadConfig(Mcp, Tools, mcpServer, getConfig, toolsToUseRef);
-
-    expect(getConfig).toHaveBeenCalledTimes(2);
-    // Each reload should tear down and reconnect
-    expect(Mcp.closeAll).toHaveBeenCalledTimes(2);
-    expect(Mcp.connectToConfigured).toHaveBeenCalledTimes(2);
-  });
-});

package/tests/test.spec.ts

@@ -1,163 +0,0 @@
-// Global mocks that need to be hoisted before any imports
-jest.mock("../src/services/S3", () => ({
-  S3Service: jest.fn().mockImplementation(() => ({
-    uploadFile: jest.fn(),
-    downloadFile: jest.fn(),
-    uploadToPresignedUrl: jest.fn(),
-    downloadFromPresignedUrl: jest.fn(),
-  })),
-}));
-jest.mock("@aws-sdk/client-s3", () => ({
-  S3Client: jest.fn(),
-}));
-jest.mock("fs");
-jest.mock("../src/plugins/plugins");
-jest.mock("../src/utils");
-jest.mock("../src/agents/tools/lintFile");
-jest.mock("../src/index");
-
-// Import modules after mocking
-import * as fs from "fs";
-import {
-  embeddingSearch,
-  readFile,
-  scanFile,
-  modifyFile,
-  execCommand,
-  writeFile,
-} from "../src/agents/tools";
-import { services } from "../src/services";
-import { patchFile } from "../src/agents/tools/patch";
-import { fileExists } from "../src/utils";
-import * as utils from "../src/utils";
-import { lintFile } from "../src/agents/tools/lintFile";
-import { embed } from "../src/index";
-
-const mockFs = jest.mocked(fs);
-const mockServices = jest.mocked(services);
-const mockUtils = jest.mocked(utils);
-const mockLintFile = jest.mocked(lintFile);
-const mockEmbed = jest.mocked(embed);
-
-describe("Agent Tools Tests", () => {
-  test("searchFiles should call the embeddings plugin with the correct keyword", async () => {
-    const { Plugins } = mockServices();
-    const expectedResult = JSON.stringify({ files: ["test1.js", "test2.js"] });
-    const mocked = Plugins as jest.Mocked<typeof Plugins>;
-    const keyword = "test";
-
-    // Setting up the plugin to return the expected result
-    mocked.call.mockResolvedValue(expectedResult);
-
-    const result = await embeddingSearch(keyword);
-
-    // Verifying that the plugin was called with the correct keyword
-    expect(Plugins.call).toHaveBeenCalledWith("embeddings", keyword);
-    // Verifying that the function returns the expected result
-    expect(result).toBe(expectedResult);
-  });
-
-  test("readFile should return the content of a file", async () => {
-    const filePath = "test.txt";
-    const fileContent = "Hello World";
-
-    mockUtils.fileExists.mockResolvedValue(true);
-
-    // Mock readFile to return the fileContent
-    mockFs.readFileSync.mockReturnValue(fileContent);
-
-    const result = await readFile(filePath);
-
-    // Verify readFile was called with the correct file path
-    expect(mockFs.readFileSync).toHaveBeenCalledWith(filePath, "utf8");
-    // Verify the result is a patch (since readFile now returns patch format)
-    expect(result).toContain(fileContent);
-  });
-
-  test("scanFile should return the contents of a specified range of lines from a file", () => {
-    const filePath = "test.txt";
-    const fileContentLines = ["Line1", "Line2", "Line3", "Line4", "Line5"];
-    const startLine = 3;
-    const endLine = 3;
-
-    // Mock fs.readFileSync to return joined fileContentLines
-    mockFs.readFileSync.mockReturnValue(fileContentLines.join("\n"));
-
-    const result = scanFile(filePath, startLine, endLine);
-
-    // Verify fs.readFileSync was called with the correct file path
-    expect(mockFs.readFileSync).toHaveBeenCalledWith(filePath, "utf8");
-    // Verify that the correct range of lines is returned
-    expect(result).toBe(
-      JSON.stringify([
-        [1, "Line1"],
-        [2, "Line2"],
-        [3, "Line3"],
-        [4, "Line4"],
-        [5, "Line5"],
-      ])
-    );
-  });
-
-  test("writeFile should write the full contents to a file", () => {
-    const filePath = "testWrite.txt";
-    const contentToWrite = "Writing to file";
-
-    // Mock fs.writeFileSync to not actually write to disk
-    mockFs.writeFileSync.mockImplementation(() => {});
-
-    const result = writeFile(filePath, contentToWrite);
-
-    // Verify fs.writeFileSync was called with the correct arguments
-    expect(mockFs.writeFileSync).toHaveBeenCalledWith(filePath, contentToWrite);
-    // Verify the function returns a success message
-    expect(result).toBe(`File ${filePath} written`);
-  });
-
-  test("applyPatchFile should apply a patch to a file", async () => {
-    const filePath = "testPatch.txt";
-    const originalContent = "Original content\n";
-    const patch = "@@ -1,1 +1,1 @@\n-Original content\n+Patched content\n";
-
-    // Mock fs.existsSync to return true (file exists)
-    mockFs.existsSync.mockReturnValue(true);
-
-    // Mock the utilities that patchFile uses
-    mockUtils.readFile.mockResolvedValue(originalContent);
-    mockUtils.writeFile.mockResolvedValue(undefined);
-    mockUtils.fileExists.mockResolvedValue(true);
-    mockUtils.mkdir.mockResolvedValue(undefined);
-    mockUtils.splitByNewLines.mockImplementation((text: string) =>
-      text.split(/\r?\n/)
-    );
-    mockLintFile.mockResolvedValue("");
-    mockEmbed.mockResolvedValue(undefined);
-
-    const result = await patchFile(filePath, patch);
-
-    // Verify the function returns a success message
-    expect(result).toContain("Patch applied to");
-  }, 60000); // Increase timeout to 60 seconds
-
-  test("execCommand should execute a system command and return its output", async () => {
-    const command = 'echo "Hello World"';
-    const expectedOutput = '$ echo "Hello World"\nHello World\n';
-
-    // Use the execCommand and expect it to return the correct result
-    const result = await execCommand(command);
-    expect(result).toEqual(expectedOutput);
-  });
-
-  test("execCommand should return an error message if the command fails", async () => {
-    const command = "exit 1";
-    const expectedOutput = "$ exit 1\nCommand failed: exit 1";
-
-    // Use the execCommand and expect it to return the correct result
-    const result = await execCommand(command);
-    expect(result.trim()).toEqual(expectedOutput);
-  });
-
-  test("it should run a test", () => {
-    expect(true).toEqual(true);
-  });
-});

package/tests/unit/InputQueueManager.test.ts

@@ -1,174 +0,0 @@
-import { InputQueueManager } from "../../src/utils/InputQueueManager";
-
-describe("InputQueueManager history ordering", () => {
-  test("should use only passed-in history for navigation", () => {
-    const manager = new InputQueueManager();
-    
-    // Simulate history passed to ask() (oldest -> newest)
-    const history = ["old1", "old2", "old3"];
-    
-    // Access the private getHistory method via reflection for testing
-    const getHistory = (manager as any).getHistory.bind(manager);
-    
-    // Simulate having a current question with history
-    (manager as any).stack = [{
-      question: "test",
-      options: [],
-      history: history,
-      resolve: () => {}
-    }];
-    
-    const result = getHistory();
-    
-    // Should return history in oldest->newest order (same as passed in)
-    expect(result).toEqual(["old1", "old2", "old3"]);
-  });
-
-  test("should sanitize history entries", () => {
-    const manager = new InputQueueManager();
-    
-    // History with entries that need sanitization
-    const history = ["normal", "has\nnewline", "  spaces  ", ""];
-    
-    const getHistory = (manager as any).getHistory.bind(manager);
-    
-    (manager as any).stack = [{
-      question: "test",
-      options: [],
-      history: history,
-      resolve: () => {}
-    }];
-    
-    const result = getHistory();
-    
-    // Should sanitize: remove newlines, trim whitespace, filter empty
-    expect(result).toEqual(["normal", "has newline", "spaces"]);
-  });
-
-  test("should return empty array when no history provided", () => {
-    const manager = new InputQueueManager();
-    
-    const getHistory = (manager as any).getHistory.bind(manager);
-    
-    // No history in stack
-    (manager as any).stack = [{
-      question: "test",
-      options: [],
-      history: undefined,
-      resolve: () => {}
-    }];
-    
-    const result = getHistory();
-    
-    expect(result).toEqual([]);
-  });
-
-  test("should return empty array when stack is empty", () => {
-    const manager = new InputQueueManager();
-    
-    const getHistory = (manager as any).getHistory.bind(manager);
-    
-    // Empty stack
-    (manager as any).stack = [];
-    
-    const result = getHistory();
-    
-    expect(result).toEqual([]);
-  });
-
-  test("Verify historyIndex math for first Up press", () => {
-    // History array: ["old1", "old2", "recent"]
-    // length = 3
-    // First Up: historyIndex becomes 0
-    // Index to access: length - 1 - historyIndex = 3 - 1 - 0 = 2
-    // history[2] = "recent" ✓
-    
-    const history = ["old1", "old2", "recent"];
-    const historyIndex = 0; // After first Up press
-    const accessIndex = history.length - 1 - historyIndex;
-    
-    expect(accessIndex).toBe(2);
-    expect(history[accessIndex]).toBe("recent");
-  });
-
-  test("Verify historyIndex math for multiple Up presses", () => {
-    // History array: ["old1", "old2", "recent"]
-    // length = 3
-    const history = ["old1", "old2", "recent"];
-    
-    // First Up: historyIndex = 0
-    expect(history[history.length - 1 - 0]).toBe("recent");
-    
-    // Second Up: historyIndex = 1
-    expect(history[history.length - 1 - 1]).toBe("old2");
-    
-    // Third Up: historyIndex = 2
-    expect(history[history.length - 1 - 2]).toBe("old1");
-  });
-
-  test("onNewEntry callback is called when set", () => {
-    const manager = new InputQueueManager();
-    const entries: string[] = [];
-    
-    manager.setOnNewEntry((entry) => {
-      entries.push(entry);
-    });
-    
-    // Verify callback is stored (we can't easily test the actual Enter key behavior without mocking readline)
-    expect((manager as any).onNewEntry).toBeDefined();
-  });
-});
-
-describe("InputQueueManager with CliChatService integration pattern", () => {
-  test("new entries should appear in history for next ask() call", () => {
-    // This test verifies the pattern used by CliChatService:
-    // 1. ask() is called with current inputHistory
-    // 2. User types and presses Enter
-    // 3. onNewEntry callback adds entry to inputHistory
-    // 4. Next ask() call includes the new entry
-    
-    const inputHistory: string[] = ["old1", "old2"];
-    const manager = new InputQueueManager();
-    
-    // Set up callback (like CliChatService does)
-    manager.setOnNewEntry((entry) => {
-      if (!entry.startsWith("/") && entry.trim() !== "") {
-        inputHistory.push(entry);
-      }
-    });
-    
-    // Simulate: first ask() call with current history
-    const getHistory = (manager as any).getHistory.bind(manager);
-    (manager as any).stack = [{
-      question: "test",
-      options: [],
-      history: [...inputHistory], // snapshot at time of ask()
-      resolve: () => {}
-    }];
-    
-    let result = getHistory();
-    expect(result).toEqual(["old1", "old2"]);
-    
-    // Simulate: user presses Enter with "new message"
-    // The callback fires (in real code this happens in the 'line' event)
-    (manager as any).onNewEntry("new message");
-    
-    // inputHistory is now updated
-    expect(inputHistory).toEqual(["old1", "old2", "new message"]);
-    
-    // Simulate: next ask() call with updated history
-    (manager as any).stack = [{
-      question: "test2",
-      options: [],
-      history: [...inputHistory], // new snapshot includes "new message"
-      resolve: () => {}
-    }];
-    
-    result = getHistory();
-    expect(result).toEqual(["old1", "old2", "new message"]);
-    
-    // Press Up: should get "new message" (the most recent)
-    const historyIndex = 0;
-    expect(result[result.length - 1 - historyIndex]).toBe("new message");
-  });
-});

package/tests/unit/McpWebsocketTransport.test.ts

@@ -1,56 +0,0 @@
-import { EventEmitter } from "events";
-import { WebSocket } from "ws";
-import { MCPWebSocketTransport } from "../../src/services/McpWebsocketTransport";
-
-class TestSocket extends EventEmitter {
-  readyState = WebSocket.OPEN;
-  // Simulate send() calling the callback immediately (required by MCPWebSocketTransport.send())
-  send = jest.fn((data: string, cb?: (err?: Error) => void) => { cb?.(); });
-  close = jest.fn();
-}
-
-const flush = () => new Promise<void>((resolve) => setImmediate(resolve));
-
-describe("MCPWebSocketTransport", () => {
-  it("delivers valid JSON-RPC frames to onmessage", async () => {
-    const socket = new TestSocket();
-    const transport = new MCPWebSocketTransport(socket as unknown as WebSocket);
-    const response = { jsonrpc: "2.0", id: 1, result: {} };
-    transport.onmessage = jest.fn();
-    transport.onerror = jest.fn();
-
-    await transport.start();
-    socket.emit("message", JSON.stringify(response));
-    await flush();
-    await flush();
-
-    expect(transport.onmessage).toHaveBeenCalledWith(response);
-    expect(transport.onerror).not.toHaveBeenCalled();
-  });
-
-  it("calls onerror for invalid JSON-RPC frames", async () => {
-    const socket = new TestSocket();
-    const transport = new MCPWebSocketTransport(socket as unknown as WebSocket);
-    const invalid = { notJsonRpc: true };
-    transport.onmessage = jest.fn();
-    transport.onerror = jest.fn();
-
-    await transport.start();
-    socket.emit("message", JSON.stringify(invalid));
-    await flush();
-
-    expect(transport.onmessage).not.toHaveBeenCalled();
-    expect(transport.onerror).toHaveBeenCalled();
-  });
-
-  it("sends serialized JSON over the socket", async () => {
-    const socket = new TestSocket();
-    const transport = new MCPWebSocketTransport(socket as unknown as WebSocket);
-    await transport.start();
-
-    const msg = { jsonrpc: "2.0" as const, method: "ping", id: 42 };
-    await transport.send(msg);
-
-    expect(socket.send).toHaveBeenCalledWith(JSON.stringify(msg), expect.any(Function));
-  });
-});

package/tests/unit/agents/historyRollback.test.ts

@@ -1,53 +0,0 @@
-import { rollbackAgentInteractions } from "../../../src/agents/historyRollback";
-import { Message } from "../../../src/clients/types";
-
-const message = (role: Message["role"], content: string): Message => ({ role, content });
-
-describe("rollbackAgentInteractions", () => {
-  const threads: Message[][] = [[
-    message("user", "request"),
-    message("assistant", "first"),
-    message("tool", "first result"),
-    message("assistant", "second"),
-    message("tool", "second result"),
-  ]];
-
-  it("clones history without changing it when rollback is zero", () => {
-    const result = rollbackAgentInteractions(threads, 0);
-    expect(result).toEqual(threads);
-    expect(result).not.toBe(threads);
-    expect(result[0]).not.toBe(threads[0]);
-    expect(result[0][0]).not.toBe(threads[0][0]);
-  });
-
-  it("removes the newest assistant and its following tool results", () => {
-    expect(rollbackAgentInteractions(threads, 1)).toEqual([threads[0].slice(0, 3)]);
-  });
-
-  it("can remove multiple interactions", () => {
-    expect(rollbackAgentInteractions(threads, 2)).toEqual([[threads[0][0]]]);
-  });
-
-  it("removes a trailing assistant without tools", () => {
-    const input = [[message("user", "request"), message("assistant", "tail")]];
-    expect(rollbackAgentInteractions(input, 1)).toEqual([[input[0][0]]]);
-  });
-
-  it.each([-1, 1.5])("rejects invalid rollback %p", (rollback) => {
-    expect(() => rollbackAgentInteractions(threads, rollback)).toThrow(
-      "rollback must be a non-negative integer"
-    );
-  });
-
-  it("rejects rollback beyond available interactions", () => {
-    expect(() => rollbackAgentInteractions(threads, 3)).toThrow(
-      "only has 2 assistant interaction(s)"
-    );
-  });
-
-  it("does not mutate input history", () => {
-    const before = JSON.stringify(threads);
-    rollbackAgentInteractions(threads, 1);
-    expect(JSON.stringify(threads)).toBe(before);
-  });
-});