whale-code 6.5.6 → 6.5.8

package/dist/cli/services/tools/__tests__/shell-exec-execution.test.js

@@ -0,0 +1,245 @@
+import { describe, it, expect, vi } from "vitest";
+
+// Mock child_process.spawn so commands are NOT actually executed.
+vi.mock("child_process", async () => {
+  const actual = await vi.importActual("child_process");
+  return {
+    ...actual,
+    spawn: vi.fn(cmd => {
+      const {
+        EventEmitter
+      } = require("events");
+      const {
+        Readable
+      } = require("stream");
+      const child = new EventEmitter();
+      const echoMatch = typeof cmd === "string" ? cmd.match(/^echo\s+(.*)/) : null;
+      let pushed = false;
+      child.stdout = new Readable({
+        read() {
+          if (echoMatch && !pushed) {
+            pushed = true;
+            this.push(echoMatch[1] + "\n");
+          }
+          this.push(null);
+        }
+      });
+      child.stderr = new Readable({
+        read() {
+          this.push(null);
+        }
+      });
+      child.stdin = {
+        write: vi.fn(),
+        end: vi.fn()
+      };
+      child.pid = 99999;
+      child.kill = vi.fn();
+      setTimeout(() => child.emit("exit", 0), 5);
+      return child;
+    })
+  };
+});
+vi.mock("../../sandbox.js", () => ({
+  sandboxCommand: vi.fn((cmd, _cwd) => ({
+    wrapped: cmd,
+    profilePath: null
+  })),
+  cleanupSandbox: vi.fn()
+}));
+vi.mock("../../background-processes.js", () => ({
+  spawnBackground: vi.fn(async () => ({
+    status: "running",
+    message: "Process started"
+  })),
+  readProcessOutput: vi.fn(_id => ({
+    status: "completed",
+    exitCode: 0,
+    newOutput: "output data",
+    newErrors: ""
+  })),
+  killProcess: vi.fn(() => ({
+    success: true,
+    message: "Process killed"
+  })),
+  listProcesses: vi.fn(() => [])
+}));
+vi.mock("../../agent-events.js", () => ({
+  getGlobalEmitter: vi.fn(() => ({
+    emitToolOutput: vi.fn()
+  }))
+}));
+vi.mock("../../debug-log.js", () => ({
+  debugLog: vi.fn()
+}));
+import { runCommand, bashOutput, killShell, listShellsFn } from "../shell-exec.js";
+import { spawnBackground, readProcessOutput, killProcess, listProcesses } from "../../background-processes.js";
+
+// ============================================================================
+// runCommand — execution features
+// ============================================================================
+
+describe("runCommand — execution", () => {
+  it("runs echo and returns output", async () => {
+    const result = await runCommand({
+      command: "echo hello"
+    });
+    expect(result.success).toBe(true);
+    expect(result.output).toContain("hello");
+  });
+  it("caps timeout at 300000ms", async () => {
+    const result = await runCommand({
+      command: "echo test",
+      timeout: 999999
+    });
+    expect(result.success).toBe(true);
+  });
+  it("uses default 30000ms timeout", async () => {
+    const result = await runCommand({
+      command: "echo test"
+    });
+    expect(result.success).toBe(true);
+  });
+  it("resolves ~ in working_directory", async () => {
+    const result = await runCommand({
+      command: "echo test",
+      working_directory: "~/Desktop"
+    });
+    expect(result.success).toBe(true);
+  });
+  it("delegates to spawnBackground when run_in_background is true", async () => {
+    const result = await runCommand({
+      command: "echo 'bg task'",
+      run_in_background: true,
+      description: "Test bg task"
+    });
+    expect(result.success).toBe(true);
+    expect(result.output).toContain("Process started");
+    expect(spawnBackground).toHaveBeenCalled();
+  });
+  it("allows commands at exactly 10000 characters", async () => {
+    const cmd = "echo " + "x".repeat(9995);
+    const result = await runCommand({
+      command: cmd
+    });
+    expect(result.output).not.toContain("Command too long");
+  });
+});
+
+// ============================================================================
+// bashOutput / killShell / listShellsFn
+// ============================================================================
+
+describe("bashOutput", () => {
+  it("returns formatted output for completed process", () => {
+    const result = bashOutput({
+      bash_id: "test-123"
+    });
+    expect(result.success).toBe(true);
+    expect(result.output).toContain("test-123");
+    expect(result.output).toContain("output data");
+  });
+  it("handles error from readProcessOutput", () => {
+    vi.mocked(readProcessOutput).mockReturnValueOnce({
+      error: "Process not found"
+    });
+    const result = bashOutput({
+      bash_id: "nonexistent"
+    });
+    expect(result.success).toBe(false);
+    expect(result.output).toContain("Process not found");
+  });
+  it("passes filter parameter", () => {
+    bashOutput({
+      bash_id: "test-123",
+      filter: "ERROR"
+    });
+    expect(readProcessOutput).toHaveBeenCalledWith("test-123", {
+      filter: "ERROR"
+    });
+  });
+  it("shows no new output message when buffers empty", () => {
+    vi.mocked(readProcessOutput).mockReturnValueOnce({
+      status: "running",
+      newOutput: "",
+      newErrors: ""
+    });
+    const result = bashOutput({
+      bash_id: "test-123"
+    });
+    expect(result.success).toBe(true);
+    expect(result.output).toContain("no new output");
+  });
+});
+describe("killShell", () => {
+  it("kills process by shell_id", () => {
+    const result = killShell({
+      shell_id: "test-123"
+    });
+    expect(result.success).toBe(true);
+    expect(result.output).toContain("Process killed");
+    expect(killProcess).toHaveBeenCalledWith("test-123");
+  });
+  it("falls back to bash_id", () => {
+    const result = killShell({
+      bash_id: "test-456"
+    });
+    expect(result.success).toBe(true);
+    expect(killProcess).toHaveBeenCalledWith("test-456");
+  });
+  it("reports failure from killProcess", () => {
+    vi.mocked(killProcess).mockReturnValueOnce({
+      success: false,
+      message: "Not found"
+    });
+    const result = killShell({
+      shell_id: "nonexistent"
+    });
+    expect(result.success).toBe(false);
+    expect(result.output).toContain("Not found");
+  });
+});
+describe("listShellsFn", () => {
+  it("returns message when no processes", () => {
+    const result = listShellsFn();
+    expect(result.success).toBe(true);
+    expect(result.output).toContain("No background processes");
+  });
+  it("lists running processes", () => {
+    vi.mocked(listProcesses).mockReturnValueOnce([{
+      id: "proc-1",
+      command: "npm run dev",
+      status: "running",
+      runtime: "5m",
+      pid: 12345,
+      outputLines: 100,
+      errorLines: 2
+    }]);
+    const result = listShellsFn();
+    expect(result.success).toBe(true);
+    expect(result.output).toContain("1 background process:");
+    expect(result.output).toContain("proc-1");
+    expect(result.output).toContain("npm run dev");
+    expect(result.output).toContain("PID: 12345");
+  });
+  it("lists multiple processes with plural label", () => {
+    vi.mocked(listProcesses).mockReturnValueOnce([{
+      id: "proc-1",
+      command: "npm run dev",
+      status: "running",
+      runtime: "5m",
+      outputLines: 10,
+      errorLines: 0
+    }, {
+      id: "proc-2",
+      command: "tsc --watch",
+      status: "completed",
+      runtime: "2m",
+      outputLines: 50,
+      errorLines: 1
+    }]);
+    const result = listShellsFn();
+    expect(result.success).toBe(true);
+    expect(result.output).toContain("2 background processes:");
+  });
+});

package/dist/cli/services/tools/__tests__/task-manager-create.test.js

@@ -0,0 +1,110 @@
+import { describe, it, expect, vi, beforeEach } from "vitest";
+
+// ============================================================================
+// Mocks
+// ============================================================================
+
+const {
+  mockWriteFileSync
+} = vi.hoisted(() => ({
+  mockWriteFileSync: vi.fn()
+}));
+vi.mock("fs", () => ({
+  readFileSync: vi.fn(path => {
+    if (path.includes("__reset__")) {
+      return JSON.stringify({
+        tasks: [],
+        counter: 0
+      });
+    }
+    throw new Error("ENOENT");
+  }),
+  writeFileSync: mockWriteFileSync,
+  existsSync: vi.fn(path => {
+    if (path.includes("__reset__")) return true;
+    if (path.includes("todos")) return true;
+    return false;
+  }),
+  mkdirSync: vi.fn()
+}));
+import { tasksTool, loadTodos, setTodoSessionId, getTodoState } from "../task-manager.js";
+
+/** Reset internal task state by loading a mock-empty session */
+function resetTaskState() {
+  loadTodos("__reset__");
+}
+beforeEach(() => {
+  vi.clearAllMocks();
+  resetTaskState();
+});
+
+// ============================================================================
+// tasksTool — create
+// ============================================================================
+
+describe("tasksTool — create", () => {
+  it("creates a task with subject and description", () => {
+    setTodoSessionId("create-test");
+    const result = tasksTool({
+      action: "create",
+      subject: "Write tests",
+      description: "Unit tests for task manager"
+    });
+    expect(result.success).toBe(true);
+    expect(result.output).toContain("Created task #");
+    expect(result.output).toContain("Write tests");
+  });
+  it("requires subject for create", () => {
+    const result = tasksTool({
+      action: "create",
+      description: "desc"
+    });
+    expect(result.success).toBe(false);
+    expect(result.output).toContain("subject and description required");
+  });
+  it("requires description for create", () => {
+    const result = tasksTool({
+      action: "create",
+      subject: "sub"
+    });
+    expect(result.success).toBe(false);
+    expect(result.output).toContain("subject and description required");
+  });
+  it("assigns incrementing IDs", () => {
+    setTodoSessionId("id-test");
+    const r1 = tasksTool({
+      action: "create",
+      subject: "Task A",
+      description: "a"
+    });
+    const r2 = tasksTool({
+      action: "create",
+      subject: "Task B",
+      description: "b"
+    });
+    expect(r1.output).toContain("#");
+    expect(r2.output).toContain("#");
+    const id1 = r1.output.match(/#(\d+)/)?.[1];
+    const id2 = r2.output.match(/#(\d+)/)?.[1];
+    expect(id1).not.toBe(id2);
+  });
+  it("stores optional metadata and owner", () => {
+    setTodoSessionId("meta-test");
+    tasksTool({
+      action: "create",
+      subject: "Task with meta",
+      description: "has metadata",
+      owner: "alice",
+      metadata: {
+        priority: "high"
+      }
+    });
+    const state = getTodoState();
+    const task = state.find(t => t.subject === "Task with meta");
+    expect(task).toBeDefined();
+    expect(task.owner).toBe("alice");
+    expect(task.metadata).toEqual({
+      priority: "high"
+    });
+  });
+});

package/dist/cli/services/tools/__tests__/task-manager-crud.test.js

@@ -0,0 +1,339 @@
+import { describe, it, expect, vi, beforeEach } from "vitest";
+
+// ============================================================================
+// Mocks
+// ============================================================================
+
+const {
+  mockWriteFileSync
+} = vi.hoisted(() => ({
+  mockWriteFileSync: vi.fn()
+}));
+vi.mock("fs", () => ({
+  readFileSync: vi.fn(path => {
+    if (path.includes("__reset__")) {
+      return JSON.stringify({
+        tasks: [],
+        counter: 0
+      });
+    }
+    if (path.includes("test-session.json")) {
+      return JSON.stringify({
+        tasks: [{
+          id: "1",
+          subject: "Loaded Task",
+          description: "From disk",
+          status: "pending",
+          blocks: [],
+          blockedBy: [],
+          createdAt: "2024-01-01T00:00:00.000Z"
+        }],
+        counter: 1
+      });
+    }
+    if (path.includes("legacy-session.json")) {
+      return JSON.stringify([{
+        content: "Old format task",
+        status: "pending"
+      }]);
+    }
+    throw new Error("ENOENT");
+  }),
+  writeFileSync: mockWriteFileSync,
+  existsSync: vi.fn(path => {
+    if (path.includes("__reset__")) return true;
+    if (path.includes("test-session.json")) return true;
+    if (path.includes("legacy-session.json")) return true;
+    if (path.includes("todos")) return true;
+    return false;
+  }),
+  mkdirSync: vi.fn()
+}));
+import { tasksTool, loadTodos, setTodoSessionId, getTodoState } from "../task-manager.js";
+
+// ============================================================================
+// Helpers
+// ============================================================================
+
+function resetTaskState() {
+  loadTodos("__reset__");
+}
+beforeEach(() => {
+  vi.clearAllMocks();
+  resetTaskState();
+});
+
+// ============================================================================
+// tasksTool — action routing
+// ============================================================================
+
+describe("tasksTool — action routing", () => {
+  it("requires action parameter", () => {
+    const result = tasksTool({});
+    expect(result.success).toBe(false);
+    expect(result.output).toContain("action is required");
+  });
+  it("rejects unknown actions", () => {
+    const result = tasksTool({
+      action: "fly"
+    });
+    expect(result.success).toBe(false);
+    expect(result.output).toContain("Unknown action");
+  });
+});
+
+// ============================================================================
+// tasksTool — create
+// ============================================================================
+
+describe("tasksTool — create", () => {
+  it("creates a task with subject and description", () => {
+    setTodoSessionId("create-test");
+    const result = tasksTool({
+      action: "create",
+      subject: "Write tests",
+      description: "Unit tests for task manager"
+    });
+    expect(result.success).toBe(true);
+    expect(result.output).toContain("Created task #");
+    expect(result.output).toContain("Write tests");
+  });
+  it("requires subject for create", () => {
+    const result = tasksTool({
+      action: "create",
+      description: "desc"
+    });
+    expect(result.success).toBe(false);
+    expect(result.output).toContain("subject and description required");
+  });
+  it("requires description for create", () => {
+    const result = tasksTool({
+      action: "create",
+      subject: "sub"
+    });
+    expect(result.success).toBe(false);
+    expect(result.output).toContain("subject and description required");
+  });
+  it("assigns incrementing IDs", () => {
+    setTodoSessionId("id-test");
+    const r1 = tasksTool({
+      action: "create",
+      subject: "Task A",
+      description: "a"
+    });
+    const r2 = tasksTool({
+      action: "create",
+      subject: "Task B",
+      description: "b"
+    });
+    expect(r1.output).toContain("#");
+    expect(r2.output).toContain("#");
+    const id1 = r1.output.match(/#(\d+)/)?.[1];
+    const id2 = r2.output.match(/#(\d+)/)?.[1];
+    expect(id1).not.toBe(id2);
+  });
+  it("stores optional metadata and owner", () => {
+    setTodoSessionId("meta-test");
+    tasksTool({
+      action: "create",
+      subject: "Task with meta",
+      description: "has metadata",
+      owner: "alice",
+      metadata: {
+        priority: "high"
+      }
+    });
+    const state = getTodoState();
+    const task = state.find(t => t.subject === "Task with meta");
+    expect(task).toBeDefined();
+    expect(task.owner).toBe("alice");
+    expect(task.metadata).toEqual({
+      priority: "high"
+    });
+  });
+});
+
+// ============================================================================
+// tasksTool — update
+// ============================================================================
+
+describe("tasksTool — update", () => {
+  beforeEach(() => {
+    setTodoSessionId("update-test");
+    tasksTool({
+      action: "create",
+      subject: "Update Me",
+      description: "original"
+    });
+  });
+  it("requires taskId for update", () => {
+    const result = tasksTool({
+      action: "update"
+    });
+    expect(result.success).toBe(false);
+    expect(result.output).toContain("taskId required");
+  });
+  it("returns error for nonexistent task", () => {
+    const result = tasksTool({
+      action: "update",
+      taskId: "999"
+    });
+    expect(result.success).toBe(false);
+    expect(result.output).toContain("not found");
+  });
+  it("updates task status", () => {
+    const state = getTodoState();
+    const taskId = state[state.length - 1].id;
+    const result = tasksTool({
+      action: "update",
+      taskId,
+      status: "in_progress"
+    });
+    expect(result.success).toBe(true);
+    expect(result.output).toContain("[in_progress]");
+  });
+  it("updates subject via subject_update", () => {
+    const state = getTodoState();
+    const taskId = state[state.length - 1].id;
+    tasksTool({
+      action: "update",
+      taskId,
+      subject_update: "New Subject"
+    });
+    const updated = getTodoState().find(t => t.id === taskId);
+    expect(updated.subject).toBe("New Subject");
+  });
+  it("updates description", () => {
+    const state = getTodoState();
+    const taskId = state[state.length - 1].id;
+    tasksTool({
+      action: "update",
+      taskId,
+      description: "new desc"
+    });
+    const updated = getTodoState().find(t => t.id === taskId);
+    expect(updated.description).toBe("new desc");
+  });
+  it("merges metadata and removes null keys", () => {
+    const state = getTodoState();
+    const taskId = state[state.length - 1].id;
+    tasksTool({
+      action: "update",
+      taskId,
+      metadata: {
+        key1: "val1",
+        key2: "val2"
+      }
+    });
+    tasksTool({
+      action: "update",
+      taskId,
+      metadata: {
+        key1: null,
+        key3: "val3"
+      }
+    });
+    const updated = getTodoState().find(t => t.id === taskId);
+    expect(updated.metadata).toEqual({
+      key2: "val2",
+      key3: "val3"
+    });
+  });
+  it("deletes a task with status='deleted'", () => {
+    const state = getTodoState();
+    const taskId = state[state.length - 1].id;
+    const countBefore = state.length;
+    const result = tasksTool({
+      action: "update",
+      taskId,
+      status: "deleted"
+    });
+    expect(result.success).toBe(true);
+    expect(result.output).toContain("Deleted");
+    expect(getTodoState().length).toBe(countBefore - 1);
+  });
+});
+
+// ============================================================================
+// tasksTool — dependencies
+// ============================================================================
+
+describe("tasksTool — dependencies", () => {
+  beforeEach(() => {
+    setTodoSessionId("dep-test");
+    tasksTool({
+      action: "create",
+      subject: "Task A",
+      description: "a"
+    });
+    tasksTool({
+      action: "create",
+      subject: "Task B",
+      description: "b"
+    });
+  });
+  it("adds blocks relationship", () => {
+    const state = getTodoState();
+    const idA = state[state.length - 2].id;
+    const idB = state[state.length - 1].id;
+    tasksTool({
+      action: "update",
+      taskId: idA,
+      addBlocks: [idB]
+    });
+    const updated = getTodoState();
+    const taskA = updated.find(t => t.id === idA);
+    const taskB = updated.find(t => t.id === idB);
+    expect(taskA.blocks).toContain(idB);
+    expect(taskB.blockedBy).toContain(idA);
+  });
+  it("adds blockedBy relationship", () => {
+    const state = getTodoState();
+    const idA = state[state.length - 2].id;
+    const idB = state[state.length - 1].id;
+    tasksTool({
+      action: "update",
+      taskId: idB,
+      addBlockedBy: [idA]
+    });
+    const updated = getTodoState();
+    const taskA = updated.find(t => t.id === idA);
+    const taskB = updated.find(t => t.id === idB);
+    expect(taskB.blockedBy).toContain(idA);
+    expect(taskA.blocks).toContain(idB);
+  });
+  it("does not duplicate dependency entries", () => {
+    const state = getTodoState();
+    const idA = state[state.length - 2].id;
+    const idB = state[state.length - 1].id;
+    tasksTool({
+      action: "update",
+      taskId: idA,
+      addBlocks: [idB]
+    });
+    tasksTool({
+      action: "update",
+      taskId: idA,
+      addBlocks: [idB]
+    });
+    const taskA = getTodoState().find(t => t.id === idA);
+    expect(taskA.blocks.filter(id => id === idB).length).toBe(1);
+  });
+  it("removes deleted task from other tasks' dependency lists", () => {
+    const state = getTodoState();
+    const idA = state[state.length - 2].id;
+    const idB = state[state.length - 1].id;
+    tasksTool({
+      action: "update",
+      taskId: idA,
+      addBlocks: [idB]
+    });
+    tasksTool({
+      action: "update",
+      taskId: idA,
+      status: "deleted"
+    });
+    const taskB = getTodoState().find(t => t.id === idB);
+    expect(taskB.blockedBy).not.toContain(idA);
+  });
+});