tower-studio 0.2.7 → 0.2.8

package/src/mcp/tools/__tests__/report-tools.test.ts

@@ -1,212 +0,0 @@
-import { describe, it, expect, vi, beforeEach } from "vitest";
-
-vi.mock("../../db", () => ({
-  db: {
-    task: { findMany: vi.fn() },
-    projectNote: { findMany: vi.fn() },
-  },
-}));
-
-import { db } from "../../db";
-import { reportTools } from "../report-tools";
-
-const mockDb = db as {
-  task: { findMany: ReturnType<typeof vi.fn> };
-  projectNote: { findMany: ReturnType<typeof vi.fn> };
-};
-
-/** Build a minimal task object matching the daily_summary include clause */
-function makeSummaryTask(overrides: {
-  id?: string;
-  title?: string;
-  status?: string;
-  priority?: string;
-  updatedAt?: Date;
-  project?: object;
-  messages?: { content: string; createdAt: Date }[];
-  executions?: { startedAt?: Date; status?: string; summary?: string | null }[];
-}) {
-  const now = new Date("2026-01-15T10:00:00Z");
-  const ws = { id: "ws1", name: "Workspace 1" };
-  const proj = { id: "p1", name: "Project 1", alias: null, workspace: ws };
-
-  return {
-    id: overrides.id ?? "task1",
-    title: overrides.title ?? "Test task",
-    status: overrides.status ?? "TODO",
-    priority: overrides.priority ?? "MEDIUM",
-    updatedAt: overrides.updatedAt ?? now,
-    createdAt: now,
-    project: overrides.project ?? proj,
-    messages: overrides.messages ?? [],
-    executions: overrides.executions ?? [],
-    labels: [],
-  };
-}
-
-/** Build a minimal task object matching the daily_todo include clause */
-function makeTodoTask(overrides: {
-  id?: string;
-  title?: string;
-  status?: string;
-  priority?: string;
-  updatedAt?: Date;
-  project?: object;
-  labels?: { label: { name: string } }[];
-  executions?: { sessionId?: string | null }[];
-}) {
-  const now = new Date("2026-01-15T10:00:00Z");
-  const ws = { id: "ws1", name: "Workspace 1" };
-  const proj = { id: "p1", name: "Project 1", alias: null, workspace: ws };
-
-  return {
-    id: overrides.id ?? "task1",
-    title: overrides.title ?? "Test task",
-    status: overrides.status ?? "TODO",
-    priority: overrides.priority ?? "MEDIUM",
-    updatedAt: overrides.updatedAt ?? now,
-    createdAt: now,
-    project: overrides.project ?? proj,
-    labels: overrides.labels ?? [],
-    executions: overrides.executions ?? [],
-  };
-}
-
-describe("report-tools (MCP)", () => {
-  beforeEach(() => {
-    vi.clearAllMocks();
-    mockDb.projectNote.findMany.mockResolvedValue([]);
-  });
-
-  // ── daily_summary ─────────────────────────────────────────────────────────
-
-  describe("daily_summary", () => {
-    it("with date param: uses date range [00:00, next day 00:00) and groups DONE/IN_PROGRESS tasks", async () => {
-      const doneTask = makeSummaryTask({ id: "t1", status: "DONE", title: "Done task" });
-      const inProgressTask = makeSummaryTask({ id: "t2", status: "IN_PROGRESS", title: "WIP task" });
-      mockDb.task.findMany.mockResolvedValue([doneTask, inProgressTask]);
-
-      const result = await reportTools.daily_summary.handler({ date: "2026-01-15" });
-
-      // Verify date range filter passed to findMany
-      const callArgs = mockDb.task.findMany.mock.calls[0][0];
-      const orClauses = callArgs.where.OR;
-      const updatedAtClause = orClauses.find((c: Record<string, unknown>) => "updatedAt" in c);
-      expect(updatedAtClause).toBeDefined();
-      const gte = updatedAtClause.updatedAt.gte as Date;
-      const lt = updatedAtClause.updatedAt.lt as Date;
-      expect(gte.getHours()).toBe(0);
-      expect(gte.getMinutes()).toBe(0);
-      const diffMs = lt.getTime() - gte.getTime();
-      expect(diffMs).toBe(24 * 60 * 60 * 1000);
-
-      // Verify grouping
-      expect(result.workspaces).toHaveLength(1);
-      const ws = result.workspaces[0];
-      expect(ws.projects).toHaveLength(1);
-      const proj = ws.projects[0];
-      expect(proj.completed).toHaveLength(1);
-      expect(proj.completed[0].id).toBe("t1");
-      expect(proj.inProgress).toHaveLength(1);
-      expect(proj.inProgress[0].id).toBe("t2");
-      expect(result.stats.totalCompleted).toBe(1);
-      expect(result.stats.totalInProgress).toBe(1);
-    });
-
-    it("without date param: defaults to today (passes Date objects to findMany)", async () => {
-      mockDb.task.findMany.mockResolvedValue([]);
-
-      const before = new Date();
-      before.setHours(0, 0, 0, 0);
-      await reportTools.daily_summary.handler({});
-      const after = new Date();
-      after.setHours(0, 0, 0, 0);
-
-      const callArgs = mockDb.task.findMany.mock.calls[0][0];
-      const orClauses = callArgs.where.OR;
-      const updatedAtClause = orClauses.find((c: Record<string, unknown>) => "updatedAt" in c);
-      const gte = updatedAtClause.updatedAt.gte as Date;
-      // gte should be today's midnight (between before and after)
-      expect(gte.getTime()).toBeGreaterThanOrEqual(before.getTime());
-      expect(gte.getTime()).toBeLessThanOrEqual(after.getTime());
-    });
-
-    it("CANCELLED tasks are excluded from completed and inProgress", async () => {
-      const cancelledTask = makeSummaryTask({ id: "t1", status: "CANCELLED" });
-      mockDb.task.findMany.mockResolvedValue([cancelledTask]);
-
-      const result = await reportTools.daily_summary.handler({});
-
-      expect(result.stats.totalCompleted).toBe(0);
-      expect(result.stats.totalInProgress).toBe(0);
-    });
-
-    it("empty result: returns empty workspaces array with zero stats", async () => {
-      mockDb.task.findMany.mockResolvedValue([]);
-
-      const result = await reportTools.daily_summary.handler({});
-
-      expect(result.workspaces).toHaveLength(0);
-      expect(result.stats.totalCompleted).toBe(0);
-      expect(result.stats.totalInProgress).toBe(0);
-      expect(result.stats.totalActive).toBe(0);
-    });
-  });
-
-  // ── daily_todo ────────────────────────────────────────────────────────────
-
-  describe("daily_todo", () => {
-    it("default call: status filter is [TODO, IN_PROGRESS, IN_REVIEW]", async () => {
-      mockDb.task.findMany.mockResolvedValue([]);
-
-      await reportTools.daily_todo.handler({});
-
-      const where = mockDb.task.findMany.mock.calls[0][0].where;
-      expect(where.status).toEqual({ in: ["TODO", "IN_PROGRESS", "IN_REVIEW"] });
-    });
-
-    it("with workspaceId: where clause includes project.workspaceId", async () => {
-      mockDb.task.findMany.mockResolvedValue([]);
-
-      await reportTools.daily_todo.handler({ workspaceId: "ws1" });
-
-      const where = mockDb.task.findMany.mock.calls[0][0].where;
-      expect(where.project).toEqual({ workspaceId: "ws1" });
-    });
-
-    it("with projectId: where clause includes projectId", async () => {
-      mockDb.task.findMany.mockResolvedValue([]);
-
-      await reportTools.daily_todo.handler({ projectId: "p1" });
-
-      const where = mockDb.task.findMany.mock.calls[0][0].where;
-      expect(where.projectId).toBe("p1");
-    });
-
-    it("with priority filter: where clause includes priority.in", async () => {
-      mockDb.task.findMany.mockResolvedValue([]);
-
-      await reportTools.daily_todo.handler({ priority: ["CRITICAL", "HIGH"] });
-
-      const where = mockDb.task.findMany.mock.calls[0][0].where;
-      expect(where.priority).toEqual({ in: ["CRITICAL", "HIGH"] });
-    });
-
-    it("stats computation: byStatus and byPriority match returned tasks", async () => {
-      const t1 = makeTodoTask({ id: "t1", status: "TODO", priority: "CRITICAL" });
-      const t2 = makeTodoTask({ id: "t2", status: "IN_PROGRESS", priority: "HIGH" });
-      const t3 = makeTodoTask({ id: "t3", status: "IN_REVIEW", priority: "CRITICAL" });
-      mockDb.task.findMany.mockResolvedValue([t1, t2, t3]);
-
-      const result = await reportTools.daily_todo.handler({});
-
-      expect(result.stats.total).toBe(3);
-      expect(result.stats.byStatus.TODO).toBe(1);
-      expect(result.stats.byStatus.IN_PROGRESS).toBe(1);
-      expect(result.stats.byStatus.IN_REVIEW).toBe(1);
-      expect(result.stats.byPriority.CRITICAL).toBe(2);
-      expect(result.stats.byPriority.HIGH).toBe(1);
-      expect(result.stats.byPriority.MEDIUM).toBe(0);
-    });
-  });
-});

package/src/mcp/tools/__tests__/task-tools.test.ts

@@ -1,418 +0,0 @@
-// @vitest-environment node
-import { vi, describe, it, expect, beforeEach } from "vitest";
-
-// Mock db BEFORE imports — vi.mock is hoisted but we need the mock available
-const mockTx = {
-  task: {
-    update: vi.fn(),
-  },
-  taskLabel: {
-    deleteMany: vi.fn(),
-    createMany: vi.fn(),
-  },
-};
-
-vi.mock("../../db", () => ({
-  db: {
-    task: {
-      findMany: vi.fn(),
-      create: vi.fn(),
-      update: vi.fn(),
-      delete: vi.fn(),
-    },
-    taskLabel: {
-      createMany: vi.fn(),
-      deleteMany: vi.fn(),
-    },
-    projectAsset: {
-      create: vi.fn(),
-    },
-    project: {
-      findUnique: vi.fn(),
-    },
-    $transaction: vi.fn(),
-  },
-}));
-
-vi.mock("child_process", () => ({
-  execFileSync: vi.fn(),
-}));
-vi.mock("next/cache", () => ({ revalidatePath: vi.fn() }));
-vi.mock("@/actions/task-actions", () => ({
-  updateTaskStatus: vi.fn(async (taskId: string, status: string) => ({ id: taskId, status })),
-}));
-
-vi.mock("fs", () => ({
-  existsSync: vi.fn(),
-  statSync: vi.fn(),
-  copyFileSync: vi.fn(),
-  mkdirSync: vi.fn(),
-}));
-
-vi.mock("@/lib/file-utils", () => ({
-  stripCacheUuidSuffix: vi.fn((filename: string) => filename.replace(/-[0-9a-f]{8}(\.[^.]+)$/i, "$1")),
-  isAssistantCachePath: vi.fn(),
-}));
-
-import { db } from "../../db";
-import { execFileSync } from "child_process";
-import { existsSync, statSync, copyFileSync, mkdirSync } from "fs";
-import { stripCacheUuidSuffix, isAssistantCachePath } from "@/lib/file-utils";
-import { taskTools } from "../task-tools";
-
-const mockDb = db as {
-  task: {
-    findMany: ReturnType<typeof vi.fn>;
-    create: ReturnType<typeof vi.fn>;
-    update: ReturnType<typeof vi.fn>;
-    delete: ReturnType<typeof vi.fn>;
-  };
-  taskLabel: {
-    createMany: ReturnType<typeof vi.fn>;
-    deleteMany: ReturnType<typeof vi.fn>;
-  };
-  projectAsset: {
-    create: ReturnType<typeof vi.fn>;
-  };
-  project: {
-    findUnique: ReturnType<typeof vi.fn>;
-  };
-  $transaction: ReturnType<typeof vi.fn>;
-};
-
-const mockExecFileSync = execFileSync as ReturnType<typeof vi.fn>;
-const mockExistsSync = existsSync as ReturnType<typeof vi.fn>;
-const mockStatSync = statSync as ReturnType<typeof vi.fn>;
-const mockCopyFileSync = copyFileSync as ReturnType<typeof vi.fn>;
-const mockMkdirSync = mkdirSync as ReturnType<typeof vi.fn>;
-const mockIsAssistantCachePath = isAssistantCachePath as ReturnType<typeof vi.fn>;
-const mockStripCacheUuidSuffix = stripCacheUuidSuffix as ReturnType<typeof vi.fn>;
-
-describe("task-tools", () => {
-  beforeEach(() => {
-    vi.clearAllMocks();
-    // Default $transaction: execute callback with mockTx
-    mockDb.$transaction.mockImplementation(async (cb: (tx: typeof mockTx) => Promise<unknown>) => cb(mockTx));
-    mockTx.task.update.mockResolvedValue({});
-    mockTx.taskLabel.deleteMany.mockResolvedValue({});
-    mockTx.taskLabel.createMany.mockResolvedValue({});
-  });
-
-  // ─── list_tasks ──────────────────────────────────────────────────────────
-
-  describe("list_tasks", () => {
-    it("calls findMany with projectId and flattens labels", async () => {
-      const mockTasks = [
-        {
-          id: "task1",
-          title: "Test Task",
-          labels: [
-            { label: { id: "label1", name: "Bug", color: "#ff0000" } },
-          ],
-        },
-      ];
-      mockDb.task.findMany.mockResolvedValue(mockTasks);
-
-      const result = await taskTools.list_tasks.handler({ projectId: "proj1" });
-
-      expect(mockDb.task.findMany).toHaveBeenCalledWith(
-        expect.objectContaining({
-          where: {
-            projectId: "proj1",
-            NOT: { labels: { some: { label: { name: "Tower", isBuiltin: true } } } },
-          },
-        })
-      );
-      expect(result[0].labels).toEqual([{ id: "label1", name: "Bug", color: "#ff0000" }]);
-    });
-
-    it("passes status filter to findMany when provided", async () => {
-      mockDb.task.findMany.mockResolvedValue([]);
-
-      await taskTools.list_tasks.handler({ projectId: "proj1", status: "IN_PROGRESS" });
-
-      expect(mockDb.task.findMany).toHaveBeenCalledWith(
-        expect.objectContaining({
-          where: {
-            projectId: "proj1",
-            status: "IN_PROGRESS",
-            NOT: { labels: { some: { label: { name: "Tower", isBuiltin: true } } } },
-          },
-        })
-      );
-    });
-  });
-
-  // ─── create_task ──────────────────────────────────────────────────────────
-
-  describe("create_task", () => {
-    it("creates task with MEDIUM priority and TODO status by default", async () => {
-      const createdTask = { id: "task1", title: "My Task", priority: "MEDIUM", status: "TODO" };
-      mockDb.task.create.mockResolvedValue(createdTask);
-
-      const result = await taskTools.create_task.handler({
-        projectId: "proj1",
-        title: "My Task",
-        autoStart: false,
-      });
-
-      expect(mockDb.task.create).toHaveBeenCalledWith({
-        data: expect.objectContaining({
-          title: "My Task",
-          projectId: "proj1",
-          priority: "MEDIUM",
-          status: "TODO",
-        }),
-      });
-      expect(result).toEqual(createdTask);
-    });
-
-    it("creates TaskLabel records when labelIds provided", async () => {
-      const createdTask = { id: "task1", title: "Labeled Task" };
-      mockDb.task.create.mockResolvedValue(createdTask);
-
-      await taskTools.create_task.handler({
-        projectId: "proj1",
-        title: "Labeled Task",
-        labelIds: ["lbl1", "lbl2"],
-        autoStart: false,
-      });
-
-      expect(mockDb.taskLabel.createMany).toHaveBeenCalledWith({
-        data: [
-          { taskId: "task1", labelId: "lbl1" },
-          { taskId: "task1", labelId: "lbl2" },
-        ],
-      });
-    });
-
-    it("copies reference files, strips UUID suffix for cache paths, creates ProjectAsset", async () => {
-      const createdTask = { id: "task1", title: "With Ref", description: "desc" };
-      mockDb.task.create.mockResolvedValue(createdTask);
-      mockDb.task.update.mockResolvedValue({ ...createdTask });
-      mockDb.projectAsset.create.mockResolvedValue({});
-
-      // existsSync: true for source file, false for dest (no collision)
-      mockExistsSync.mockImplementation((p: string) => {
-        if (p === "/cache/assistant/2026-04/images/design-a1b2c3d4.png") return true; // source exists
-        return false; // dest does not exist
-      });
-      mockStatSync.mockReturnValue({ isFile: () => true, size: 1024 });
-      mockIsAssistantCachePath.mockReturnValue(true);
-      mockStripCacheUuidSuffix.mockReturnValue("design.png");
-
-      await taskTools.create_task.handler({
-        projectId: "proj1",
-        title: "With Ref",
-        references: ["/cache/assistant/2026-04/images/design-a1b2c3d4.png"],
-        autoStart: false,
-      });
-
-      expect(mockIsAssistantCachePath).toHaveBeenCalledWith("/cache/assistant/2026-04/images/design-a1b2c3d4.png");
-      expect(mockStripCacheUuidSuffix).toHaveBeenCalledWith("design-a1b2c3d4.png");
-      expect(mockCopyFileSync).toHaveBeenCalled();
-      expect(mockDb.projectAsset.create).toHaveBeenCalledWith(
-        expect.objectContaining({
-          data: expect.objectContaining({
-            filename: "design.png",
-            projectId: "proj1",
-            taskId: "task1",
-          }),
-        })
-      );
-    });
-
-    it("uses counter suffix for cache file collision", async () => {
-      const createdTask = { id: "task1", title: "Collision", description: null };
-      mockDb.task.create.mockResolvedValue(createdTask);
-      mockDb.task.update.mockResolvedValue({ ...createdTask });
-      mockDb.projectAsset.create.mockResolvedValue({});
-
-      mockIsAssistantCachePath.mockReturnValue(true);
-      mockStripCacheUuidSuffix.mockReturnValue("design.png");
-
-      // existsSync: source true, dest "design.png" true (collision), "design (1).png" false
-      mockExistsSync.mockImplementation((p: string) => {
-        if (p === "/cache/design-a1b2c3d4.png") return true;
-        if (typeof p === "string" && p.endsWith("design.png")) return true;
-        if (typeof p === "string" && p.includes("design (1).png")) return false;
-        return false;
-      });
-      mockStatSync.mockReturnValue({ isFile: () => true, size: 512 });
-
-      await taskTools.create_task.handler({
-        projectId: "proj1",
-        title: "Collision",
-        references: ["/cache/design-a1b2c3d4.png"],
-        autoStart: false,
-      });
-
-      // Should have used "design (1).png" as the dest filename
-      expect(mockCopyFileSync).toHaveBeenCalled();
-      const copyCall = mockCopyFileSync.mock.calls[0];
-      expect(copyCall[1]).toContain("design (1).png");
-    });
-
-    it("auto-detects baseBranch via git when useWorktree=true and no baseBranch given", async () => {
-      const createdTask = { id: "task1", title: "Worktree Task" };
-      mockDb.task.create.mockResolvedValue(createdTask);
-      mockDb.project.findUnique.mockResolvedValue({ localPath: "/home/user/project" });
-      mockExecFileSync.mockReturnValue("main\n");
-
-      await taskTools.create_task.handler({
-        projectId: "proj1",
-        title: "Worktree Task",
-        useWorktree: true,
-        autoStart: false,
-      });
-
-      expect(mockDb.project.findUnique).toHaveBeenCalledWith({
-        where: { id: "proj1" },
-        select: { localPath: true },
-      });
-      expect(mockExecFileSync).toHaveBeenCalledWith(
-        "git",
-        ["branch", "--show-current"],
-        expect.objectContaining({ cwd: "/home/user/project" })
-      );
-      expect(mockDb.task.create).toHaveBeenCalledWith(
-        expect.objectContaining({
-          data: expect.objectContaining({ baseBranch: "main" }),
-        })
-      );
-    });
-
-    it("uses provided baseBranch and skips git detection when explicit baseBranch given", async () => {
-      const createdTask = { id: "task1", title: "Explicit Branch" };
-      mockDb.task.create.mockResolvedValue(createdTask);
-
-      await taskTools.create_task.handler({
-        projectId: "proj1",
-        title: "Explicit Branch",
-        useWorktree: true,
-        baseBranch: "feature/my-branch",
-        autoStart: false,
-      });
-
-      expect(mockExecFileSync).not.toHaveBeenCalled();
-      expect(mockDb.project.findUnique).not.toHaveBeenCalled();
-      expect(mockDb.task.create).toHaveBeenCalledWith(
-        expect.objectContaining({
-          data: expect.objectContaining({ baseBranch: "feature/my-branch" }),
-        })
-      );
-    });
-
-    it("calls fetch to start execution when autoStart=true", async () => {
-      const createdTask = { id: "task-autostart-01", title: "AutoStart Task", description: "start me" };
-      mockDb.task.create.mockResolvedValue(createdTask);
-
-      const mockFetchResponse = { ok: true, json: vi.fn().mockResolvedValue({ executionId: "exec1" }) };
-      global.fetch = vi.fn().mockResolvedValue(mockFetchResponse);
-
-      await taskTools.create_task.handler({
-        projectId: "proj1",
-        title: "AutoStart Task",
-        description: "start me",
-        autoStart: true,
-      });
-
-      // Prompt is the task title — startPtyExecution injects the description as context separately.
-      expect(global.fetch).toHaveBeenCalledWith(
-        expect.stringContaining("/api/internal/terminal/task-autostart-01/start"),
-        expect.objectContaining({
-          method: "POST",
-          body: expect.stringContaining("AutoStart Task"),
-        })
-      );
-    });
-
-    it("does NOT call fetch when autoStart=false", async () => {
-      const createdTask = { id: "task2", title: "No Auto" };
-      mockDb.task.create.mockResolvedValue(createdTask);
-      global.fetch = vi.fn();
-
-      await taskTools.create_task.handler({
-        projectId: "proj1",
-        title: "No Auto",
-        autoStart: false,
-      });
-
-      expect(global.fetch).not.toHaveBeenCalled();
-    });
-  });
-
-  // ─── update_task ──────────────────────────────────────────────────────────
-
-  describe("update_task", () => {
-    it("calls db.task.update with provided fields", async () => {
-      const updatedTask = { id: "task1", title: "Updated" };
-      mockTx.task.update.mockResolvedValue(updatedTask);
-
-      const result = await taskTools.update_task.handler({
-        taskId: "task1",
-        title: "Updated",
-        priority: "HIGH",
-      });
-
-      expect(mockDb.$transaction).toHaveBeenCalled();
-      expect(mockTx.task.update).toHaveBeenCalledWith({
-        where: { id: "task1" },
-        data: { title: "Updated", priority: "HIGH" },
-      });
-      expect(result).toEqual(updatedTask);
-    });
-
-    it("deletes existing labels then creates new ones when labelIds provided", async () => {
-      const callOrder: string[] = [];
-      mockTx.task.update.mockResolvedValue({ id: "task1" });
-      mockTx.taskLabel.deleteMany.mockImplementation(() => {
-        callOrder.push("deleteMany");
-        return Promise.resolve({});
-      });
-      mockTx.taskLabel.createMany.mockImplementation(() => {
-        callOrder.push("createMany");
-        return Promise.resolve({});
-      });
-
-      await taskTools.update_task.handler({
-        taskId: "task1",
-        labelIds: ["lbl1", "lbl2"],
-      });
-
-      expect(mockTx.taskLabel.deleteMany).toHaveBeenCalledWith({ where: { taskId: "task1" } });
-      expect(mockTx.taskLabel.createMany).toHaveBeenCalledWith({
-        data: [
-          { taskId: "task1", labelId: "lbl1" },
-          { taskId: "task1", labelId: "lbl2" },
-        ],
-      });
-      expect(callOrder).toEqual(["deleteMany", "createMany"]);
-    });
-  });
-
-  // ─── move_task ────────────────────────────────────────────────────────────
-
-  describe("move_task", () => {
-    it("delegates to updateTaskStatus", async () => {
-      const result = await taskTools.move_task.handler({ taskId: "task1", status: "DONE" });
-
-      const { updateTaskStatus } = await import("@/actions/task-actions");
-      expect(updateTaskStatus).toHaveBeenCalledWith("task1", "DONE");
-      expect(result).toEqual({ id: "task1", status: "DONE" });
-    });
-  });
-
-  // ─── delete_task ──────────────────────────────────────────────────────────
-
-  describe("delete_task", () => {
-    it("deletes task and returns confirmation", async () => {
-      mockDb.task.delete.mockResolvedValue({ id: "task1" });
-
-      const result = await taskTools.delete_task.handler({ taskId: "task1" });
-
-      expect(mockDb.task.delete).toHaveBeenCalledWith({ where: { id: "task1" } });
-      expect(result).toEqual({ deleted: true, taskId: "task1" });
-    });
-  });
-});