tower-studio 0.2.7 → 0.2.8

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

@@ -1,318 +0,0 @@
-import { vi, describe, it, expect, beforeAll, beforeEach } from "vitest";
-
-// Mock db before any imports
-vi.mock("../../db", () => ({
-  db: {
-    taskExecution: {
-      findFirst: vi.fn(),
-    },
-  },
-}));
-
-// Mock global.fetch before any imports
-const mockFetch = vi.fn();
-global.fetch = mockFetch;
-
-import { db } from "../../db";
-import { terminalTools } from "../terminal-tools";
-
-const mockDb = db as {
-  taskExecution: {
-    findFirst: ReturnType<typeof vi.fn>;
-  };
-};
-
-// Helper to create mock fetch response
-function mockFetchResponse(status: number, data: unknown): Response {
-  return {
-    ok: status >= 200 && status < 400,
-    status,
-    json: () => Promise.resolve(data),
-  } as unknown as Response;
-}
-
-// Valid CUID-format task ID for tests
-const VALID_TASK_ID = "cjldlkfxz0000ld08001abcde";
-
-describe("terminal-tools", () => {
-  beforeAll(() => {
-    // Ensure PORT is set for bridge URL
-    process.env.PORT = "3000";
-  });
-
-  beforeEach(() => {
-    vi.clearAllMocks();
-  });
-
-  describe("CUID validation", () => {
-    it("returns error immediately for invalid taskId without calling fetch", async () => {
-      const result = await terminalTools.get_task_terminal_output.handler({ taskId: "invalid" });
-
-      expect(mockFetch).not.toHaveBeenCalled();
-      expect(result).toMatchObject({
-        error: expect.stringContaining("Invalid taskId"),
-        taskId: "invalid",
-      });
-    });
-
-    it("returns error for numeric-looking taskId", async () => {
-      const result = await terminalTools.get_task_terminal_output.handler({ taskId: "12345" });
-
-      expect(mockFetch).not.toHaveBeenCalled();
-      expect(result).toMatchObject({ error: expect.stringContaining("Invalid taskId") });
-    });
-
-    it("returns error for taskId with hyphens (not CUID format)", async () => {
-      const result = await terminalTools.send_task_terminal_input.handler({
-        taskId: "not-a-cuid-format",
-        text: "hello",
-      });
-
-      expect(mockFetch).not.toHaveBeenCalled();
-      expect(result).toMatchObject({ error: expect.stringContaining("Invalid taskId") });
-    });
-  });
-
-  describe("start_task_execution", () => {
-    it("POSTs to /{taskId}/start and returns ok: true with merged data on success", async () => {
-      const mockData = { executionId: "exec1", worktreePath: "/tmp/wt" };
-      mockFetch.mockResolvedValue(mockFetchResponse(200, mockData));
-
-      const result = await terminalTools.start_task_execution.handler({
-        taskId: VALID_TASK_ID,
-        prompt: "do something",
-      });
-
-      expect(mockFetch).toHaveBeenCalledOnce();
-      const [url, init] = mockFetch.mock.calls[0];
-      expect(url).toContain(`/api/internal/terminal/${VALID_TASK_ID}/start`);
-      expect(init.method).toBe("POST");
-      expect(JSON.parse(init.body)).toEqual({ prompt: "do something" });
-
-      expect(result).toMatchObject({ ok: true, executionId: "exec1", worktreePath: "/tmp/wt" });
-    });
-
-    it("returns error with status on non-ok response", async () => {
-      const errData = { error: "Task not found" };
-      mockFetch.mockResolvedValue(mockFetchResponse(404, errData));
-
-      const result = await terminalTools.start_task_execution.handler({
-        taskId: VALID_TASK_ID,
-        prompt: "do something",
-      });
-
-      expect(result).toMatchObject({ error: "Task not found", status: 404 });
-    });
-
-    it("uses empty string as default prompt when not provided", async () => {
-      mockFetch.mockResolvedValue(mockFetchResponse(200, { executionId: "exec1" }));
-
-      await terminalTools.start_task_execution.handler({ taskId: VALID_TASK_ID });
-
-      const [, init] = mockFetch.mock.calls[0];
-      expect(JSON.parse(init.body)).toEqual({ prompt: "" });
-    });
-  });
-
-  describe("get_task_terminal_output", () => {
-    it("GETs /{taskId}/buffer?lines=N and returns lines/total/killed on 200", async () => {
-      const mockData = {
-        taskId: VALID_TASK_ID,
-        lines: ["line1", "line2"],
-        total: 2,
-        killed: false,
-      };
-      mockFetch.mockResolvedValue(mockFetchResponse(200, mockData));
-
-      const result = await terminalTools.get_task_terminal_output.handler({
-        taskId: VALID_TASK_ID,
-        lines: 20,
-      });
-
-      expect(mockFetch).toHaveBeenCalledOnce();
-      const [url] = mockFetch.mock.calls[0];
-      expect(url).toContain(`/api/internal/terminal/${VALID_TASK_ID}/buffer?lines=20`);
-
-      expect(result).toEqual({
-        taskId: VALID_TASK_ID,
-        lines: ["line1", "line2"],
-        total: 2,
-        killed: false,
-      });
-    });
-
-    it("returns 'No active terminal session' error on 404", async () => {
-      mockFetch.mockResolvedValue(mockFetchResponse(404, {}));
-
-      const result = await terminalTools.get_task_terminal_output.handler({
-        taskId: VALID_TASK_ID,
-        lines: 10,
-      });
-
-      expect(result).toMatchObject({
-        error: "No active terminal session for this task",
-        taskId: VALID_TASK_ID,
-      });
-    });
-
-    it("uses default lines=50 when lines param not provided", async () => {
-      mockFetch.mockResolvedValue(
-        mockFetchResponse(200, { taskId: VALID_TASK_ID, lines: [], total: 0, killed: false })
-      );
-
-      await terminalTools.get_task_terminal_output.handler({ taskId: VALID_TASK_ID });
-
-      const [url] = mockFetch.mock.calls[0];
-      expect(url).toContain("buffer?lines=50");
-    });
-  });
-
-  describe("send_task_terminal_input", () => {
-    it("POSTs to /{taskId}/input with text body and returns ok: true on success", async () => {
-      mockFetch.mockResolvedValue(mockFetchResponse(200, {}));
-
-      const result = await terminalTools.send_task_terminal_input.handler({
-        taskId: VALID_TASK_ID,
-        text: "hello\n",
-      });
-
-      expect(mockFetch).toHaveBeenCalledOnce();
-      const [url, init] = mockFetch.mock.calls[0];
-      expect(url).toContain(`/api/internal/terminal/${VALID_TASK_ID}/input`);
-      expect(init.method).toBe("POST");
-      expect(JSON.parse(init.body)).toEqual({ text: "hello\n" });
-
-      expect(result).toMatchObject({ ok: true, taskId: VALID_TASK_ID });
-    });
-
-    it("returns 'No active terminal session' error on 404", async () => {
-      mockFetch.mockResolvedValue(mockFetchResponse(404, {}));
-
-      const result = await terminalTools.send_task_terminal_input.handler({
-        taskId: VALID_TASK_ID,
-        text: "hello",
-      });
-
-      expect(result).toMatchObject({
-        error: "No active terminal session for this task",
-        taskId: VALID_TASK_ID,
-      });
-    });
-
-    it("returns 'Terminal session has exited' error on 410", async () => {
-      mockFetch.mockResolvedValue(mockFetchResponse(410, {}));
-
-      const result = await terminalTools.send_task_terminal_input.handler({
-        taskId: VALID_TASK_ID,
-        text: "hello",
-      });
-
-      expect(result).toMatchObject({
-        error: "Terminal session has exited",
-        taskId: VALID_TASK_ID,
-      });
-    });
-  });
-
-  describe("get_task_execution_status", () => {
-    it("returns error when no execution found in db", async () => {
-      mockDb.taskExecution.findFirst.mockResolvedValue(null);
-
-      const result = await terminalTools.get_task_execution_status.handler({
-        taskId: VALID_TASK_ID,
-      });
-
-      expect(result).toMatchObject({
-        error: "No execution found for this task",
-        taskId: VALID_TASK_ID,
-      });
-      expect(mockFetch).not.toHaveBeenCalled();
-    });
-
-    it("returns terminalStatus=exited when buffer returns 404 and execution is COMPLETED", async () => {
-      mockDb.taskExecution.findFirst.mockResolvedValue({
-        id: "exec1",
-        status: "COMPLETED",
-        startedAt: null,
-        endedAt: null,
-      });
-      mockFetch.mockResolvedValue(mockFetchResponse(404, {}));
-
-      const result = await terminalTools.get_task_execution_status.handler({
-        taskId: VALID_TASK_ID,
-      });
-
-      expect(result).toMatchObject({
-        taskId: VALID_TASK_ID,
-        executionId: "exec1",
-        executionStatus: "COMPLETED",
-        terminalStatus: "exited",
-        outputSnippet: null,
-      });
-    });
-
-    it("returns terminalStatus=not_running when buffer returns 404 and execution is RUNNING", async () => {
-      mockDb.taskExecution.findFirst.mockResolvedValue({
-        id: "exec1",
-        status: "RUNNING",
-        startedAt: null,
-        endedAt: null,
-      });
-      mockFetch.mockResolvedValue(mockFetchResponse(404, {}));
-
-      const result = await terminalTools.get_task_execution_status.handler({
-        taskId: VALID_TASK_ID,
-      });
-
-      expect(result).toMatchObject({
-        terminalStatus: "not_running",
-      });
-    });
-
-    it("returns terminalStatus=exited when buffer is ok and killed=true", async () => {
-      mockDb.taskExecution.findFirst.mockResolvedValue({
-        id: "exec1",
-        status: "RUNNING",
-        startedAt: null,
-        endedAt: null,
-      });
-      mockFetch.mockResolvedValue(
-        mockFetchResponse(200, { lines: ["done"], killed: true })
-      );
-
-      const result = await terminalTools.get_task_execution_status.handler({
-        taskId: VALID_TASK_ID,
-      });
-
-      expect(result).toMatchObject({
-        terminalStatus: "exited",
-        outputSnippet: "done",
-      });
-    });
-
-    it("returns terminalStatus=running with outputSnippet when buffer is ok and killed=false", async () => {
-      mockDb.taskExecution.findFirst.mockResolvedValue({
-        id: "exec1",
-        status: "RUNNING",
-        startedAt: null,
-        endedAt: null,
-      });
-      mockFetch.mockResolvedValue(
-        mockFetchResponse(200, { lines: ["line1", "line2", "line3"], killed: false })
-      );
-
-      const result = await terminalTools.get_task_execution_status.handler({
-        taskId: VALID_TASK_ID,
-      });
-
-      expect(result).toMatchObject({
-        terminalStatus: "running",
-        outputSnippet: "line1\nline2\nline3",
-      });
-
-      // Verify bridge fetch was called with buffer?lines=10
-      const [url] = mockFetch.mock.calls[0];
-      expect(url).toContain(`/api/internal/terminal/${VALID_TASK_ID}/buffer?lines=10`);
-    });
-  });
-});

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

@@ -1,146 +0,0 @@
-import { vi, describe, it, expect, beforeEach } from "vitest";
-
-// Mock db before any imports
-vi.mock("../../db", () => ({
-  db: {
-    workspace: {
-      findMany: vi.fn(),
-      create: vi.fn(),
-      update: vi.fn(),
-      delete: vi.fn(),
-      count: vi.fn(),
-    },
-  },
-}));
-
-import { db } from "../../db";
-import { workspaceTools } from "../workspace-tools";
-
-const mockDb = db as unknown as {
-  workspace: {
-    findMany: ReturnType<typeof vi.fn>;
-    create: ReturnType<typeof vi.fn>;
-    update: ReturnType<typeof vi.fn>;
-    delete: ReturnType<typeof vi.fn>;
-    count: ReturnType<typeof vi.fn>;
-  };
-};
-
-describe("workspace-tools", () => {
-  beforeEach(() => {
-    vi.clearAllMocks();
-  });
-
-  describe("list_workspaces", () => {
-    it("calls db.workspace.findMany with projects include and returns projectCount", async () => {
-      const mockWorkspaces = [
-        {
-          id: "ws1",
-          name: "Workspace 1",
-          description: null,
-          createdAt: new Date(),
-          updatedAt: new Date(),
-          projects: [{ id: "p1" }, { id: "p2" }],
-        },
-        {
-          id: "ws2",
-          name: "Workspace 2",
-          description: "desc",
-          createdAt: new Date(),
-          updatedAt: new Date(),
-          projects: [],
-        },
-      ];
-      mockDb.workspace.findMany.mockResolvedValue(mockWorkspaces);
-
-      const result = await workspaceTools.list_workspaces.handler({});
-
-      expect(mockDb.workspace.findMany).toHaveBeenCalledOnce();
-      const callArgs = mockDb.workspace.findMany.mock.calls[0][0];
-      expect(callArgs.include.projects).toBeDefined();
-      expect(callArgs.orderBy).toEqual({ updatedAt: "desc" });
-
-      expect(result).toHaveLength(2);
-      expect(result[0]).toMatchObject({ id: "ws1", name: "Workspace 1", projectCount: 2 });
-      expect(result[0]).not.toHaveProperty("projects");
-      expect(result[1]).toMatchObject({ id: "ws2", name: "Workspace 2", projectCount: 0 });
-    });
-  });
-
-  describe("create_workspace", () => {
-    it("calls db.workspace.create with name and description", async () => {
-      const mockWorkspace = { id: "ws1", name: "New WS", description: "My desc", createdAt: new Date(), updatedAt: new Date() };
-      mockDb.workspace.create.mockResolvedValue(mockWorkspace);
-
-      const result = await workspaceTools.create_workspace.handler({ name: "New WS", description: "My desc" });
-
-      expect(mockDb.workspace.create).toHaveBeenCalledWith({
-        data: { name: "New WS", description: "My desc" },
-      });
-      expect(result).toEqual(mockWorkspace);
-    });
-
-    it("calls db.workspace.create without description when not provided", async () => {
-      const mockWorkspace = { id: "ws1", name: "No Desc", description: null, createdAt: new Date(), updatedAt: new Date() };
-      mockDb.workspace.create.mockResolvedValue(mockWorkspace);
-
-      await workspaceTools.create_workspace.handler({ name: "No Desc" });
-
-      expect(mockDb.workspace.create).toHaveBeenCalledWith({
-        data: { name: "No Desc", description: undefined },
-      });
-    });
-  });
-
-  describe("update_workspace", () => {
-    it("calls db.workspace.update with correct where and data", async () => {
-      const mockWorkspace = { id: "ws1", name: "Updated", description: "new desc", createdAt: new Date(), updatedAt: new Date() };
-      mockDb.workspace.update.mockResolvedValue(mockWorkspace);
-
-      const result = await workspaceTools.update_workspace.handler({
-        workspaceId: "ws1",
-        name: "Updated",
-        description: "new desc",
-      });
-
-      expect(mockDb.workspace.update).toHaveBeenCalledWith({
-        where: { id: "ws1" },
-        data: { name: "Updated", description: "new desc" },
-      });
-      expect(result).toEqual(mockWorkspace);
-    });
-
-    it("calls db.workspace.update with partial data (name only)", async () => {
-      const mockWorkspace = { id: "ws1", name: "Renamed", description: null, createdAt: new Date(), updatedAt: new Date() };
-      mockDb.workspace.update.mockResolvedValue(mockWorkspace);
-
-      await workspaceTools.update_workspace.handler({ workspaceId: "ws1", name: "Renamed" });
-
-      expect(mockDb.workspace.update).toHaveBeenCalledWith({
-        where: { id: "ws1" },
-        data: { name: "Renamed", description: undefined },
-      });
-    });
-  });
-
-  describe("delete_workspace", () => {
-    it("calls db.workspace.delete with workspaceId and returns deleted: true", async () => {
-      mockDb.workspace.count.mockResolvedValue(2);
-      mockDb.workspace.delete.mockResolvedValue({ id: "ws1" });
-
-      const result = await workspaceTools.delete_workspace.handler({ workspaceId: "ws1" });
-
-      expect(mockDb.workspace.delete).toHaveBeenCalledWith({ where: { id: "ws1" } });
-      expect(result).toEqual({ deleted: true, workspaceId: "ws1" });
-    });
-
-    it("throws when trying to delete the last workspace", async () => {
-      mockDb.workspace.count.mockResolvedValue(1);
-
-      await expect(
-        workspaceTools.delete_workspace.handler({ workspaceId: "ws1" }),
-      ).rejects.toThrow("Cannot delete the last workspace");
-      expect(mockDb.workspace.delete).not.toHaveBeenCalled();
-    });
-  });
-});

package/src/mcp/tools/knowledge-tools.ts

@@ -1,100 +0,0 @@
-import { z } from "zod";
-import { db } from "../db";
-
-// Scoring constants
-const NAME_EXACT = 1.0;
-const NAME_STARTS_WITH = 0.9;
-const NAME_CONTAINS = 0.75;
-const ALIAS_EXACT = 0.85;
-const ALIAS_STARTS_WITH = 0.75;
-const ALIAS_CONTAINS = 0.6;
-const DESC_CONTAINS = 0.4;
-const MIN_CONFIDENCE = 0.3;
-
-interface ProjectFields {
-  name: string;
-  alias: string | null;
-  description?: string | null;
-}
-
-/**
- * Score a project against a query string.
- * Returns a confidence value between 0 and 1.
- * Name match > alias match > description match.
- */
-export function scoreProject(project: ProjectFields, query: string): number {
-  const q = query.toLowerCase();
-  const name = project.name.toLowerCase();
-
-  // Name scoring
-  let nameScore = 0;
-  if (name === q) {
-    nameScore = NAME_EXACT;
-  } else if (name.startsWith(q)) {
-    nameScore = NAME_STARTS_WITH;
-  } else if (name.includes(q)) {
-    nameScore = NAME_CONTAINS;
-  }
-
-  // Alias scoring
-  let aliasScore = 0;
-  if (project.alias) {
-    const alias = project.alias.toLowerCase();
-    if (alias === q) {
-      aliasScore = ALIAS_EXACT;
-    } else if (alias.startsWith(q)) {
-      aliasScore = ALIAS_STARTS_WITH;
-    } else if (alias.includes(q)) {
-      aliasScore = ALIAS_CONTAINS;
-    }
-  }
-
-  // Description scoring
-  let descScore = 0;
-  if (project.description) {
-    const desc = project.description.toLowerCase();
-    if (desc.includes(q)) {
-      descScore = DESC_CONTAINS;
-    }
-  }
-
-  return Math.max(nameScore, aliasScore, descScore);
-}
-
-export const knowledgeTools = {
-  identify_project: {
-    description:
-      "Find a project by partial name, alias, or description. Returns matches sorted by confidence score (0-1).",
-    schema: z.object({
-      query: z.string(),
-      workspaceId: z.string().optional(),
-    }),
-    handler: async (args: { query: string; workspaceId?: string }) => {
-      // Fetch all projects (with workspace) optionally filtered by workspaceId
-      const projects = await db.project.findMany({
-        where: args.workspaceId ? { workspaceId: args.workspaceId } : undefined,
-        include: { workspace: true },
-      });
-
-      // Score each project
-      const scored = projects
-        .map((project) => ({
-          projectId: project.id,
-          name: project.name,
-          alias: project.alias,
-          workspaceId: project.workspaceId,
-          workspaceName: project.workspace.name,
-          confidence: scoreProject(
-            { name: project.name, alias: project.alias, description: project.description },
-            args.query
-          ),
-        }))
-        // Filter out low-confidence results
-        .filter((result) => result.confidence >= MIN_CONFIDENCE)
-        // Sort by confidence descending
-        .sort((a, b) => b.confidence - a.confidence);
-
-      return scored;
-    },
-  },
-};

package/src/mcp/tools/label-tools.ts

@@ -1,70 +0,0 @@
-import { z } from "zod";
-import { db } from "../db";
-
-export const labelTools = {
-  list_labels: {
-    description: "List all labels available for a workspace, including builtin labels and workspace-specific labels.",
-    schema: z.object({
-      workspaceId: z.string(),
-    }),
-    handler: async (args: { workspaceId: string }) => {
-      return db.label.findMany({
-        where: {
-          OR: [
-            { isBuiltin: true },
-            { workspaceId: args.workspaceId },
-          ],
-        },
-        orderBy: [{ isBuiltin: "desc" }, { name: "asc" }],
-      });
-    },
-  },
-
-  create_label: {
-    description: "Create a custom label for a workspace with a name and color.",
-    schema: z.object({
-      workspaceId: z.string(),
-      name: z.string(),
-      color: z.string().regex(/^#[0-9a-fA-F]{6}$/, "Color must be a hex color code like #ff0000"),
-    }),
-    handler: async (args: { workspaceId: string; name: string; color: string }) => {
-      return db.label.create({
-        data: {
-          name: args.name,
-          color: args.color,
-          workspaceId: args.workspaceId,
-        },
-      });
-    },
-  },
-
-  delete_label: {
-    description: "Delete a label by ID.",
-    schema: z.object({
-      labelId: z.string(),
-    }),
-    handler: async (args: { labelId: string }) => {
-      await db.label.delete({ where: { id: args.labelId } });
-      return { deleted: true };
-    },
-  },
-
-  set_task_labels: {
-    description: "Replace all labels on a task with the provided list of label IDs.",
-    schema: z.object({
-      taskId: z.string(),
-      labelIds: z.array(z.string()),
-    }),
-    handler: async (args: { taskId: string; labelIds: string[] }) => {
-      await db.$transaction(async (tx) => {
-        await tx.taskLabel.deleteMany({ where: { taskId: args.taskId } });
-        if (args.labelIds.length > 0) {
-          await tx.taskLabel.createMany({
-            data: args.labelIds.map((labelId) => ({ taskId: args.taskId, labelId })),
-          });
-        }
-      });
-      return { taskId: args.taskId, labelIds: args.labelIds };
-    },
-  },
-};