whale-code 6.5.6 → 6.5.8

package/dist/cli/services/__tests__/local-tools-dispatch.test.js

@@ -0,0 +1,404 @@
+/**
+ * Tests for local-tools.ts — executeLocalTool dispatch and read_many_files
+ */
+import { describe, it, expect, vi, beforeEach } from "vitest";
+vi.mock("../tools/file-ops.js", () => ({
+  readFile: vi.fn(async () => ({
+    success: true,
+    output: "file content"
+  })),
+  writeFile: vi.fn(() => ({
+    success: true,
+    output: "written"
+  })),
+  editFile: vi.fn(() => ({
+    success: true,
+    output: "edited"
+  })),
+  multiEdit: vi.fn(() => ({
+    success: true,
+    output: "multi-edited"
+  })),
+  notebookEdit: vi.fn(() => ({
+    success: true,
+    output: "notebook edited"
+  })),
+  listDirectory: vi.fn(() => ({
+    success: true,
+    output: "dir listing"
+  })),
+  searchFiles: vi.fn(() => ({
+    success: true,
+    output: "files found"
+  })),
+  searchContent: vi.fn(() => ({
+    success: true,
+    output: "content found"
+  })),
+  resolvePath: vi.fn(p => p)
+}));
+vi.mock("../tools/search-tools.js", () => ({
+  globSearch: vi.fn(() => ({
+    success: true,
+    output: "3 files:\nfoo.ts\nbar.ts\nbaz.ts"
+  })),
+  grepSearch: vi.fn(() => ({
+    success: true,
+    output: "grep results"
+  }))
+}));
+vi.mock("../tools/shell-exec.js", () => ({
+  runCommand: vi.fn(async () => ({
+    success: true,
+    output: "cmd output"
+  })),
+  bashOutput: vi.fn(() => ({
+    success: true,
+    output: "bash output"
+  })),
+  killShell: vi.fn(() => ({
+    success: true,
+    output: "killed"
+  })),
+  listShellsFn: vi.fn(() => ({
+    success: true,
+    output: "no shells"
+  }))
+}));
+vi.mock("../tools/web-tools.js", () => ({
+  webFetch: vi.fn(async () => ({
+    success: true,
+    output: "fetched"
+  })),
+  webSearch: vi.fn(async () => ({
+    success: true,
+    output: "search results"
+  }))
+}));
+vi.mock("../tools/task-manager.js", () => ({
+  tasksTool: vi.fn(() => ({
+    success: true,
+    output: "tasks ok"
+  })),
+  loadTodos: vi.fn(),
+  setTodoSessionId: vi.fn(),
+  getTodoState: vi.fn(() => ({}))
+}));
+vi.mock("../tools/agent-tools.js", () => ({
+  taskTool: vi.fn(async () => ({
+    success: true,
+    output: "task result"
+  })),
+  teamCreateTool: vi.fn(async () => ({
+    success: true,
+    output: "team created"
+  })),
+  taskOutput: vi.fn(async () => ({
+    success: true,
+    output: "task output"
+  })),
+  taskStop: vi.fn(() => ({
+    success: true,
+    output: "stopped"
+  })),
+  configTool: vi.fn(() => ({
+    success: true,
+    output: "config ok"
+  })),
+  askUser: vi.fn(() => ({
+    success: true,
+    output: "ask user ok"
+  })),
+  lspTool: vi.fn(async () => ({
+    success: true,
+    output: "lsp result"
+  })),
+  skillTool: vi.fn(() => ({
+    success: true,
+    output: "skill ok"
+  }))
+}));
+vi.mock("fs", () => ({
+  readFileSync: vi.fn(() => "file line 1\nfile line 2\n"),
+  existsSync: vi.fn(() => true),
+  statSync: vi.fn(() => ({
+    size: 100
+  }))
+}));
+vi.mock("path", async () => {
+  const actual = await vi.importActual("path");
+  return {
+    ...actual,
+    resolve: vi.fn((...args) => args.join("/"))
+  };
+});
+import { executeLocalTool } from "../local-tools.js";
+import { readFile, writeFile, editFile, multiEdit, notebookEdit, listDirectory, searchFiles, searchContent } from "../tools/file-ops.js";
+import { globSearch, grepSearch } from "../tools/search-tools.js";
+import { runCommand, bashOutput, killShell, listShellsFn } from "../tools/shell-exec.js";
+import { webFetch, webSearch } from "../tools/web-tools.js";
+import { tasksTool } from "../tools/task-manager.js";
+import { taskTool, teamCreateTool, taskOutput, taskStop, configTool, askUser, lspTool, skillTool } from "../tools/agent-tools.js";
+describe("executeLocalTool", () => {
+  beforeEach(() => {
+    vi.clearAllMocks();
+  });
+  it("dispatches read_file", async () => {
+    const result = await executeLocalTool("read_file", {
+      path: "/tmp/x.ts"
+    });
+    expect(result.success).toBe(true);
+    expect(readFile).toHaveBeenCalledWith({
+      path: "/tmp/x.ts"
+    });
+  });
+  it("dispatches write_file", async () => {
+    const result = await executeLocalTool("write_file", {
+      path: "/tmp/x.ts",
+      content: "hello"
+    });
+    expect(result.success).toBe(true);
+    expect(writeFile).toHaveBeenCalledWith({
+      path: "/tmp/x.ts",
+      content: "hello"
+    });
+  });
+  it("dispatches edit_file", async () => {
+    const result = await executeLocalTool("edit_file", {
+      path: "/tmp/x.ts",
+      old_string: "a",
+      new_string: "b"
+    });
+    expect(result.success).toBe(true);
+    expect(editFile).toHaveBeenCalled();
+  });
+  it("dispatches list_directory", async () => {
+    const result = await executeLocalTool("list_directory", {
+      path: "/tmp"
+    });
+    expect(result.success).toBe(true);
+    expect(listDirectory).toHaveBeenCalledWith({
+      path: "/tmp"
+    });
+  });
+  it("dispatches search_files", async () => {
+    const result = await executeLocalTool("search_files", {
+      pattern: "*.ts",
+      path: "/tmp"
+    });
+    expect(result.success).toBe(true);
+    expect(searchFiles).toHaveBeenCalled();
+  });
+  it("dispatches search_content", async () => {
+    const result = await executeLocalTool("search_content", {
+      query: "foo",
+      path: "/tmp"
+    });
+    expect(result.success).toBe(true);
+    expect(searchContent).toHaveBeenCalled();
+  });
+  it("dispatches multi_edit", async () => {
+    const result = await executeLocalTool("multi_edit", {
+      file_path: "/x.ts",
+      edits: []
+    });
+    expect(result.success).toBe(true);
+    expect(multiEdit).toHaveBeenCalled();
+  });
+  it("dispatches notebook_edit", async () => {
+    const result = await executeLocalTool("notebook_edit", {
+      notebook_path: "/x.ipynb",
+      new_source: "a"
+    });
+    expect(result.success).toBe(true);
+    expect(notebookEdit).toHaveBeenCalled();
+  });
+  it("dispatches glob", async () => {
+    const result = await executeLocalTool("glob", {
+      pattern: "**/*.ts"
+    });
+    expect(result.success).toBe(true);
+    expect(globSearch).toHaveBeenCalled();
+  });
+  it("dispatches grep", async () => {
+    const result = await executeLocalTool("grep", {
+      pattern: "import"
+    });
+    expect(result.success).toBe(true);
+    expect(grepSearch).toHaveBeenCalled();
+  });
+  it("dispatches run_command", async () => {
+    const result = await executeLocalTool("run_command", {
+      command: "ls"
+    });
+    expect(result.success).toBe(true);
+    expect(runCommand).toHaveBeenCalled();
+  });
+  it("dispatches bash_output", async () => {
+    const result = await executeLocalTool("bash_output", {
+      bash_id: "123"
+    });
+    expect(result.success).toBe(true);
+    expect(bashOutput).toHaveBeenCalled();
+  });
+  it("dispatches kill_shell", async () => {
+    const result = await executeLocalTool("kill_shell", {
+      shell_id: "123"
+    });
+    expect(result.success).toBe(true);
+    expect(killShell).toHaveBeenCalled();
+  });
+  it("dispatches list_shells", async () => {
+    const result = await executeLocalTool("list_shells", {});
+    expect(result.success).toBe(true);
+    expect(listShellsFn).toHaveBeenCalled();
+  });
+  it("dispatches web_fetch", async () => {
+    const result = await executeLocalTool("web_fetch", {
+      url: "https://example.com"
+    });
+    expect(result.success).toBe(true);
+    expect(webFetch).toHaveBeenCalled();
+  });
+  it("dispatches web_search", async () => {
+    const result = await executeLocalTool("web_search", {
+      query: "vitest"
+    });
+    expect(result.success).toBe(true);
+    expect(webSearch).toHaveBeenCalled();
+  });
+  it("dispatches tasks", async () => {
+    const result = await executeLocalTool("tasks", {
+      action: "list"
+    });
+    expect(result.success).toBe(true);
+    expect(tasksTool).toHaveBeenCalled();
+  });
+  it("dispatches task (subagent)", async () => {
+    const result = await executeLocalTool("task", {
+      prompt: "do x",
+      subagent_type: "explore"
+    });
+    expect(result.success).toBe(true);
+    expect(taskTool).toHaveBeenCalled();
+  });
+  it("dispatches team_create", async () => {
+    const result = await executeLocalTool("team_create", {
+      name: "t",
+      teammate_count: 2,
+      tasks: []
+    });
+    expect(result.success).toBe(true);
+    expect(teamCreateTool).toHaveBeenCalled();
+  });
+  it("dispatches task_output", async () => {
+    const result = await executeLocalTool("task_output", {
+      task_id: "a-1"
+    });
+    expect(result.success).toBe(true);
+    expect(taskOutput).toHaveBeenCalled();
+  });
+  it("dispatches task_stop", async () => {
+    const result = await executeLocalTool("task_stop", {
+      task_id: "a-1"
+    });
+    expect(result.success).toBe(true);
+    expect(taskStop).toHaveBeenCalled();
+  });
+  it("dispatches config", async () => {
+    const result = await executeLocalTool("config", {
+      setting: "model"
+    });
+    expect(result.success).toBe(true);
+    expect(configTool).toHaveBeenCalled();
+  });
+  it("dispatches ask_user", async () => {
+    const result = await executeLocalTool("ask_user", {
+      question: "?",
+      options: []
+    });
+    expect(result.success).toBe(true);
+    expect(askUser).toHaveBeenCalled();
+  });
+  it("dispatches lsp", async () => {
+    const result = await executeLocalTool("lsp", {
+      operation: "hover",
+      filePath: "x.ts",
+      line: 1,
+      character: 1
+    });
+    expect(result.success).toBe(true);
+    expect(lspTool).toHaveBeenCalled();
+  });
+  it("dispatches skill", async () => {
+    const result = await executeLocalTool("skill", {
+      skill: "commit"
+    });
+    expect(result.success).toBe(true);
+    expect(skillTool).toHaveBeenCalled();
+  });
+  it("returns error for unknown tools", async () => {
+    const result = await executeLocalTool("totally_unknown", {});
+    expect(result.success).toBe(false);
+    expect(result.output).toContain("Unknown local tool");
+  });
+  it("catches thrown errors and returns failure", async () => {
+    vi.mocked(readFile).mockRejectedValueOnce(new Error("read boom"));
+    const result = await executeLocalTool("read_file", {
+      path: "/crash"
+    });
+    expect(result.success).toBe(false);
+    expect(result.output).toContain("Error");
+  });
+});
+describe("read_many_files via executeLocalTool", () => {
+  beforeEach(() => {
+    vi.clearAllMocks();
+  });
+  it("reads files matching glob pattern", async () => {
+    const result = await executeLocalTool("read_many_files", {
+      pattern: "*.ts"
+    });
+    expect(result.success).toBe(true);
+    expect(result.output).toContain("Read");
+  });
+  it("returns 'No files matched' when globSearch returns no matches", async () => {
+    vi.mocked(globSearch).mockReturnValueOnce({
+      success: true,
+      output: "No files found"
+    });
+    const result = await executeLocalTool("read_many_files", {
+      pattern: "*.xyz"
+    });
+    expect(result.success).toBe(true);
+    expect(result.output).toContain("No files matched");
+  });
+  it("returns error when globSearch fails", async () => {
+    vi.mocked(globSearch).mockReturnValueOnce({
+      success: false,
+      output: "glob error"
+    });
+    const result = await executeLocalTool("read_many_files", {
+      pattern: "bad"
+    });
+    expect(result.success).toBe(false);
+  });
+  it("skips binary files", async () => {
+    vi.mocked(globSearch).mockReturnValueOnce({
+      success: true,
+      output: "2 files:\nimage.png\ncode.ts"
+    });
+    const result = await executeLocalTool("read_many_files", {
+      pattern: "*"
+    });
+    expect(result.success).toBe(true);
+    expect(result.output).toContain("[Binary file");
+  });
+  it("respects the limit parameter (capped at 50)", async () => {
+    const result = await executeLocalTool("read_many_files", {
+      pattern: "*.ts",
+      limit: 1
+    });
+    expect(result.success).toBe(true);
+  });
+});

package/dist/cli/services/__tests__/local-tools.test.js

@@ -0,0 +1,238 @@
+/**
+ * Tests for local-tools.ts — tool registry and definitions
+ */
+import { describe, it, expect, vi, beforeEach } from "vitest";
+vi.mock("../tools/file-ops.js", () => ({
+  readFile: vi.fn(async () => ({
+    success: true,
+    output: "file content"
+  })),
+  writeFile: vi.fn(() => ({
+    success: true,
+    output: "written"
+  })),
+  editFile: vi.fn(() => ({
+    success: true,
+    output: "edited"
+  })),
+  multiEdit: vi.fn(() => ({
+    success: true,
+    output: "multi-edited"
+  })),
+  notebookEdit: vi.fn(() => ({
+    success: true,
+    output: "notebook edited"
+  })),
+  listDirectory: vi.fn(() => ({
+    success: true,
+    output: "dir listing"
+  })),
+  searchFiles: vi.fn(() => ({
+    success: true,
+    output: "files found"
+  })),
+  searchContent: vi.fn(() => ({
+    success: true,
+    output: "content found"
+  })),
+  resolvePath: vi.fn(p => p)
+}));
+vi.mock("../tools/search-tools.js", () => ({
+  globSearch: vi.fn(() => ({
+    success: true,
+    output: "3 files:\nfoo.ts\nbar.ts\nbaz.ts"
+  })),
+  grepSearch: vi.fn(() => ({
+    success: true,
+    output: "grep results"
+  }))
+}));
+vi.mock("../tools/shell-exec.js", () => ({
+  runCommand: vi.fn(async () => ({
+    success: true,
+    output: "cmd output"
+  })),
+  bashOutput: vi.fn(() => ({
+    success: true,
+    output: "bash output"
+  })),
+  killShell: vi.fn(() => ({
+    success: true,
+    output: "killed"
+  })),
+  listShellsFn: vi.fn(() => ({
+    success: true,
+    output: "no shells"
+  }))
+}));
+vi.mock("../tools/web-tools.js", () => ({
+  webFetch: vi.fn(async () => ({
+    success: true,
+    output: "fetched"
+  })),
+  webSearch: vi.fn(async () => ({
+    success: true,
+    output: "search results"
+  }))
+}));
+vi.mock("../tools/task-manager.js", () => ({
+  tasksTool: vi.fn(() => ({
+    success: true,
+    output: "tasks ok"
+  })),
+  loadTodos: vi.fn(),
+  setTodoSessionId: vi.fn(),
+  getTodoState: vi.fn(() => ({}))
+}));
+vi.mock("../tools/agent-tools.js", () => ({
+  taskTool: vi.fn(async () => ({
+    success: true,
+    output: "task result"
+  })),
+  teamCreateTool: vi.fn(async () => ({
+    success: true,
+    output: "team created"
+  })),
+  taskOutput: vi.fn(async () => ({
+    success: true,
+    output: "task output"
+  })),
+  taskStop: vi.fn(() => ({
+    success: true,
+    output: "stopped"
+  })),
+  configTool: vi.fn(() => ({
+    success: true,
+    output: "config ok"
+  })),
+  askUser: vi.fn(() => ({
+    success: true,
+    output: "ask user ok"
+  })),
+  lspTool: vi.fn(async () => ({
+    success: true,
+    output: "lsp result"
+  })),
+  skillTool: vi.fn(() => ({
+    success: true,
+    output: "skill ok"
+  }))
+}));
+vi.mock("fs", () => ({
+  readFileSync: vi.fn(() => "file line 1\nfile line 2\n"),
+  existsSync: vi.fn(() => true),
+  statSync: vi.fn(() => ({
+    size: 100
+  }))
+}));
+vi.mock("path", async () => {
+  const actual = await vi.importActual("path");
+  return {
+    ...actual,
+    resolve: vi.fn((...args) => args.join("/"))
+  };
+});
+import { LOCAL_TOOL_NAMES, LOCAL_TOOL_DEFINITIONS, isLocalTool } from "../local-tools.js";
+describe("local-tools", () => {
+  beforeEach(() => {
+    vi.clearAllMocks();
+  });
+  describe("LOCAL_TOOL_NAMES", () => {
+    it("is a Set", () => {
+      expect(LOCAL_TOOL_NAMES).toBeInstanceOf(Set);
+    });
+    it("contains core file tools", () => {
+      expect(LOCAL_TOOL_NAMES.has("read_file")).toBe(true);
+      expect(LOCAL_TOOL_NAMES.has("write_file")).toBe(true);
+      expect(LOCAL_TOOL_NAMES.has("edit_file")).toBe(true);
+      expect(LOCAL_TOOL_NAMES.has("list_directory")).toBe(true);
+    });
+    it("contains search tools", () => {
+      expect(LOCAL_TOOL_NAMES.has("glob")).toBe(true);
+      expect(LOCAL_TOOL_NAMES.has("grep")).toBe(true);
+      expect(LOCAL_TOOL_NAMES.has("search_files")).toBe(true);
+      expect(LOCAL_TOOL_NAMES.has("search_content")).toBe(true);
+    });
+    it("contains shell tools", () => {
+      expect(LOCAL_TOOL_NAMES.has("run_command")).toBe(true);
+      expect(LOCAL_TOOL_NAMES.has("bash_output")).toBe(true);
+      expect(LOCAL_TOOL_NAMES.has("kill_shell")).toBe(true);
+      expect(LOCAL_TOOL_NAMES.has("list_shells")).toBe(true);
+    });
+    it("contains web tools", () => {
+      expect(LOCAL_TOOL_NAMES.has("web_fetch")).toBe(true);
+      expect(LOCAL_TOOL_NAMES.has("web_search")).toBe(true);
+    });
+    it("contains agent tools", () => {
+      expect(LOCAL_TOOL_NAMES.has("task")).toBe(true);
+      expect(LOCAL_TOOL_NAMES.has("team_create")).toBe(true);
+      expect(LOCAL_TOOL_NAMES.has("task_output")).toBe(true);
+      expect(LOCAL_TOOL_NAMES.has("task_stop")).toBe(true);
+      expect(LOCAL_TOOL_NAMES.has("config")).toBe(true);
+      expect(LOCAL_TOOL_NAMES.has("ask_user")).toBe(true);
+      expect(LOCAL_TOOL_NAMES.has("lsp")).toBe(true);
+      expect(LOCAL_TOOL_NAMES.has("skill")).toBe(true);
+    });
+    it("contains task management tools", () => {
+      expect(LOCAL_TOOL_NAMES.has("tasks")).toBe(true);
+      expect(LOCAL_TOOL_NAMES.has("multi_edit")).toBe(true);
+      expect(LOCAL_TOOL_NAMES.has("notebook_edit")).toBe(true);
+      expect(LOCAL_TOOL_NAMES.has("read_many_files")).toBe(true);
+    });
+    it("does not contain made-up tool names", () => {
+      expect(LOCAL_TOOL_NAMES.has("does_not_exist")).toBe(false);
+      expect(LOCAL_TOOL_NAMES.has("")).toBe(false);
+    });
+  });
+  describe("isLocalTool", () => {
+    it("returns true for known local tools", () => {
+      expect(isLocalTool("read_file")).toBe(true);
+      expect(isLocalTool("glob")).toBe(true);
+      expect(isLocalTool("run_command")).toBe(true);
+    });
+    it("returns false for unknown tool names", () => {
+      expect(isLocalTool("nonexistent_tool")).toBe(false);
+      expect(isLocalTool("")).toBe(false);
+      expect(isLocalTool("server_only_tool")).toBe(false);
+    });
+  });
+  describe("LOCAL_TOOL_DEFINITIONS", () => {
+    it("is an array of tool definition objects", () => {
+      expect(Array.isArray(LOCAL_TOOL_DEFINITIONS)).toBe(true);
+      expect(LOCAL_TOOL_DEFINITIONS.length).toBeGreaterThan(10);
+    });
+    it("each definition has name, description, and input_schema", () => {
+      for (const def of LOCAL_TOOL_DEFINITIONS) {
+        expect(def).toHaveProperty("name");
+        expect(def).toHaveProperty("description");
+        expect(def).toHaveProperty("input_schema");
+        expect(def.input_schema.type).toBe("object");
+        expect(typeof def.name).toBe("string");
+        expect(typeof def.description).toBe("string");
+      }
+    });
+    it("all definition names are in LOCAL_TOOL_NAMES", () => {
+      for (const def of LOCAL_TOOL_DEFINITIONS) {
+        expect(LOCAL_TOOL_NAMES.has(def.name)).toBe(true);
+      }
+    });
+    it("read_file definition has correct required fields", () => {
+      const readFileDef = LOCAL_TOOL_DEFINITIONS.find(d => d.name === "read_file");
+      expect(readFileDef).toBeDefined();
+      expect(readFileDef.input_schema.required).toContain("path");
+    });
+    it("grep definition includes output_mode enum", () => {
+      const grepDef = LOCAL_TOOL_DEFINITIONS.find(d => d.name === "grep");
+      expect(grepDef).toBeDefined();
+      const outputMode = grepDef.input_schema.properties.output_mode;
+      expect(outputMode.enum).toEqual(["content", "files_with_matches", "count"]);
+    });
+    it("task definition includes subagent_type enum", () => {
+      const taskDef = LOCAL_TOOL_DEFINITIONS.find(d => d.name === "task");
+      expect(taskDef).toBeDefined();
+      const subagentType = taskDef.input_schema.properties.subagent_type;
+      expect(subagentType.enum).toContain("explore");
+      expect(subagentType.enum).toContain("general-purpose");
+    });
+  });
+});