tower-studio 0.2.7 → 0.2.9

package/src/mcp/tools/note-asset-tools.ts

@@ -1,271 +0,0 @@
-import { z } from "zod";
-import * as fs from "node:fs";
-import * as path from "node:path";
-import { db } from "../db";
-import { searchNotes, syncNoteToFts, deleteNoteFromFts } from "@/lib/fts";
-import { ensureAssetsDir } from "@/lib/file-utils";
-
-// ─── manage_notes ────────────────────────────────────────────────────────────
-
-const manageNotesSchema = z.object({
-  action: z.enum(["create", "update", "delete", "get", "list", "search"]),
-  projectId: z.string().optional(),
-  noteId: z.string().optional(),
-  title: z.string().optional(),
-  content: z.string().optional(),
-  category: z.string().optional(),
-  query: z.string().optional(),
-});
-
-type ManageNotesArgs = z.infer<typeof manageNotesSchema>;
-
-async function handleManageNotes(args: ManageNotesArgs) {
-  switch (args.action) {
-    case "create": {
-      if (!args.projectId || !args.title) {
-        throw new Error("projectId and title required");
-      }
-      const note = await db.projectNote.create({
-        data: {
-          title: args.title,
-          content: args.content ?? "",
-          category: args.category ?? "备忘",
-          projectId: args.projectId,
-        },
-      });
-      await syncNoteToFts(db, { id: note.id, title: note.title, content: note.content });
-      return note;
-    }
-
-    case "update": {
-      if (!args.noteId) {
-        throw new Error("noteId required");
-      }
-      const updateData: { title?: string; content?: string; category?: string } = {};
-      if (args.title !== undefined) updateData.title = args.title;
-      if (args.content !== undefined) updateData.content = args.content;
-      if (args.category !== undefined) updateData.category = args.category;
-
-      const note = await db.projectNote.update({
-        where: { id: args.noteId },
-        data: updateData,
-      });
-      await syncNoteToFts(db, { id: note.id, title: note.title, content: note.content });
-      return note;
-    }
-
-    case "delete": {
-      if (!args.noteId) {
-        throw new Error("noteId required");
-      }
-      await deleteNoteFromFts(db, args.noteId);
-      await db.projectNote.delete({ where: { id: args.noteId } });
-      return { deleted: true, noteId: args.noteId };
-    }
-
-    case "get": {
-      if (!args.noteId) {
-        throw new Error("noteId required");
-      }
-      return db.projectNote.findUnique({ where: { id: args.noteId } });
-    }
-
-    case "list": {
-      if (!args.projectId) {
-        throw new Error("projectId required");
-      }
-      const where: { projectId: string; category?: string } = { projectId: args.projectId };
-      if (args.category) where.category = args.category;
-
-      return db.projectNote.findMany({
-        where,
-        orderBy: { updatedAt: "desc" },
-      });
-    }
-
-    case "search": {
-      if (!args.projectId || !args.query) {
-        throw new Error("projectId and query required");
-      }
-      return searchNotes(db, args.projectId, args.query);
-    }
-
-    default:
-      throw new Error(`Unknown action: ${args.action}`);
-  }
-}
-
-// ─── manage_assets ───────────────────────────────────────────────────────────
-
-const manageAssetsSchema = z.object({
-  action: z.enum(["add", "upload", "delete", "list", "get", "link_task"]),
-  projectId: z.string().optional(),
-  assetId: z.string().optional(),
-  assetIds: z.array(z.string()).optional(),
-  taskId: z.string().optional(),
-  sourcePath: z.string().optional(),
-  filename: z.string().optional(),
-  base64: z.string().optional().describe("Base64-encoded file content (for action=upload)"),
-  mimeType: z.string().optional().describe("MIME type of the uploaded file (e.g. image/png)"),
-  description: z.string().optional(),
-});
-
-type ManageAssetsArgs = z.infer<typeof manageAssetsSchema>;
-
-// Map common MIME types to file extensions
-const MIME_EXT: Record<string, string> = {
-  "image/png": ".png",
-  "image/jpeg": ".jpg",
-  "image/gif": ".gif",
-  "image/webp": ".webp",
-  "image/svg+xml": ".svg",
-  "application/pdf": ".pdf",
-  "text/plain": ".txt",
-  "text/markdown": ".md",
-  "application/json": ".json",
-};
-
-async function handleManageAssets(args: ManageAssetsArgs) {
-  switch (args.action) {
-    case "add": {
-      if (!args.projectId || !args.sourcePath) {
-        throw new Error("projectId and sourcePath required");
-      }
-      const assetsDir = ensureAssetsDir(args.projectId);
-      const filename = args.filename ?? path.basename(args.sourcePath);
-      const destPath = path.join(assetsDir, filename);
-
-      // Move file: try rename first, fall back to copy+delete for cross-device
-      try {
-        fs.renameSync(args.sourcePath, destPath);
-      } catch (err) {
-        const nodeErr = err as NodeJS.ErrnoException;
-        if (nodeErr.code === "EXDEV") {
-          fs.copyFileSync(args.sourcePath, destPath);
-          fs.unlinkSync(args.sourcePath);
-        } else {
-          throw err;
-        }
-      }
-
-      const stats = fs.statSync(destPath);
-      const asset = await db.projectAsset.create({
-        data: {
-          filename,
-          path: destPath,
-          size: stats.size,
-          mimeType: args.mimeType,
-          projectId: args.projectId,
-          taskId: args.taskId,
-          description: args.description,
-        },
-      });
-      return asset;
-    }
-
-    case "upload": {
-      if (!args.projectId || !args.base64) {
-        throw new Error("projectId and base64 required");
-      }
-      const buffer = Buffer.from(args.base64, "base64");
-      const assetsDir = ensureAssetsDir(args.projectId);
-
-      // Determine filename
-      let filename = args.filename;
-      if (!filename) {
-        const ext = (args.mimeType && MIME_EXT[args.mimeType]) || ".bin";
-        filename = `upload-${Date.now()}${ext}`;
-      }
-
-      // Avoid overwriting
-      let destPath = path.join(assetsDir, filename);
-      if (fs.existsSync(destPath)) {
-        const ext = path.extname(filename);
-        const base = path.basename(filename, ext);
-        filename = `${base}-${Date.now()}${ext}`;
-        destPath = path.join(assetsDir, filename);
-      }
-
-      fs.writeFileSync(destPath, buffer);
-
-      const asset = await db.projectAsset.create({
-        data: {
-          filename,
-          path: destPath,
-          size: buffer.length,
-          mimeType: args.mimeType,
-          projectId: args.projectId,
-          taskId: args.taskId,
-          description: args.description,
-        },
-      });
-      return asset;
-    }
-
-    case "link_task": {
-      if (!args.taskId) {
-        throw new Error("taskId required");
-      }
-      if (!args.assetIds || args.assetIds.length === 0) {
-        throw new Error("assetIds required (array of asset IDs to link)");
-      }
-      const updated = await db.projectAsset.updateMany({
-        where: { id: { in: args.assetIds } },
-        data: { taskId: args.taskId },
-      });
-      return { linked: updated.count, taskId: args.taskId, assetIds: args.assetIds };
-    }
-
-    case "delete": {
-      if (!args.assetId) {
-        throw new Error("assetId required");
-      }
-      // Also delete the file from disk
-      const asset = await db.projectAsset.findUnique({ where: { id: args.assetId } });
-      if (asset?.path && fs.existsSync(asset.path)) {
-        fs.unlinkSync(asset.path);
-      }
-      await db.projectAsset.delete({ where: { id: args.assetId } });
-      return { deleted: true, assetId: args.assetId };
-    }
-
-    case "list": {
-      if (!args.projectId) {
-        throw new Error("projectId required");
-      }
-      const where: { projectId: string; taskId?: string } = { projectId: args.projectId };
-      if (args.taskId) where.taskId = args.taskId;
-      return db.projectAsset.findMany({
-        where,
-        orderBy: { createdAt: "desc" },
-      });
-    }
-
-    case "get": {
-      if (!args.assetId) {
-        throw new Error("assetId required");
-      }
-      return db.projectAsset.findUnique({ where: { id: args.assetId } });
-    }
-
-    default:
-      throw new Error(`Unknown action: ${args.action}`);
-  }
-}
-
-// ─── Exports ─────────────────────────────────────────────────────────────────
-
-export const noteAssetTools = {
-  manage_notes: {
-    description:
-      "Create, read, update, delete, or search project notes. Use action field to select operation.",
-    schema: manageNotesSchema,
-    handler: handleManageNotes,
-  },
-  manage_assets: {
-    description:
-      "Manage project assets (files, images, screenshots). Actions: add (move file from sourcePath), upload (save base64 content — use this for pasted screenshots/images), link_task (associate uploaded assets with a task after creation), delete, list, get. Upload flow: 1) upload with projectId+base64 → get assetId+path, 2) use path in task description, 3) after create_task, call link_task with taskId+assetIds.",
-    schema: manageAssetsSchema,
-    handler: handleManageAssets,
-  },
-};

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

@@ -1,79 +0,0 @@
-import { z } from "zod";
-import { db } from "../db";
-
-export const projectTools = {
-  list_projects: {
-    description: "List all projects in a workspace ordered by last updated, including task and repository counts.",
-    schema: z.object({
-      workspaceId: z.string(),
-    }),
-    handler: async (args: { workspaceId: string }) => {
-      const projects = await db.project.findMany({
-        where: { workspaceId: args.workspaceId },
-        include: {
-          tasks: { select: { id: true } },
-          repositories: { select: { id: true } },
-        },
-        orderBy: { updatedAt: "desc" },
-      });
-
-      return projects.map(({ tasks, repositories, ...rest }) => ({
-        ...rest,
-        taskCount: tasks.length,
-        repositoryCount: repositories.length,
-      }));
-    },
-  },
-
-  create_project: {
-    description: "Create a new project in a workspace. Type is derived from gitUrl: GIT if provided, NORMAL otherwise.",
-    schema: z.object({
-      workspaceId: z.string(),
-      name: z.string(),
-      alias: z.string().optional().describe("Short alias for the project"),
-      gitUrl: z.string().optional(),
-      localPath: z.string().optional(),
-    }),
-    handler: async (args: { workspaceId: string; name: string; alias?: string; gitUrl?: string; localPath?: string }) => {
-      return db.project.create({
-        data: {
-          name: args.name,
-          alias: args.alias,
-          type: args.gitUrl ? "GIT" : "NORMAL",
-          gitUrl: args.gitUrl,
-          localPath: args.localPath,
-          workspaceId: args.workspaceId,
-        },
-      });
-    },
-  },
-
-  update_project: {
-    description: "Update an existing project's name, localPath, and/or description.",
-    schema: z.object({
-      projectId: z.string(),
-      name: z.string().optional(),
-      alias: z.string().optional().describe("Short alias for the project"),
-      localPath: z.string().optional(),
-      description: z.string().optional(),
-    }),
-    handler: async (args: { projectId: string; name?: string; alias?: string; localPath?: string; description?: string }) => {
-      const { projectId, ...data } = args;
-      return db.project.update({
-        where: { id: projectId },
-        data,
-      });
-    },
-  },
-
-  delete_project: {
-    description: "Delete a project by ID.",
-    schema: z.object({
-      projectId: z.string(),
-    }),
-    handler: async (args: { projectId: string }) => {
-      await db.project.delete({ where: { id: args.projectId } });
-      return { deleted: true, projectId: args.projectId };
-    },
-  },
-};

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

@@ -1,220 +0,0 @@
-import { z } from "zod";
-import { db } from "../db";
-
-const PRIORITY_ORDER: Record<string, number> = { CRITICAL: 0, HIGH: 1, MEDIUM: 2, LOW: 3 };
-
-export const reportTools = {
-  daily_summary: {
-    description:
-      "Get a summary of today's work across all workspaces. Shows completed tasks, in-progress tasks with their last chat summary, grouped by workspace → project. Also includes session-insight notes created that day in an `insights` array. Optionally pass a date (YYYY-MM-DD) to query a specific day. Date boundary is server-local time.",
-    schema: z.object({
-      date: z.string().regex(/^\d{4}-\d{2}-\d{2}$/).optional()
-        .describe("Date in YYYY-MM-DD format. Defaults to today."),
-    }),
-    handler: async (args: { date?: string }) => {
-      const date = args.date ? new Date(args.date + "T00:00:00") : new Date();
-      date.setHours(0, 0, 0, 0);
-      const nextDay = new Date(date);
-      nextDay.setDate(nextDay.getDate() + 1);
-
-      const tasks = await db.task.findMany({
-        where: {
-          OR: [
-            { updatedAt: { gte: date, lt: nextDay } },
-            { executions: { some: { startedAt: { gte: date, lt: nextDay } } } },
-            { messages: { some: { createdAt: { gte: date, lt: nextDay } } } },
-          ],
-          // Exclude system tasks tagged with the builtin "Tower" label
-          NOT: { labels: { some: { label: { name: "Tower", isBuiltin: true } } } },
-        },
-        include: {
-          project: { include: { workspace: true } },
-          messages: {
-            where: { role: "ASSISTANT", createdAt: { gte: date, lt: nextDay } },
-            orderBy: { createdAt: "desc" },
-            take: 1,
-            select: { content: true, createdAt: true },
-          },
-          executions: {
-            where: { startedAt: { gte: date, lt: nextDay } },
-            orderBy: { startedAt: "desc" },
-            take: 1,
-            select: { startedAt: true, status: true, summary: true },
-          },
-        },
-        orderBy: { updatedAt: "desc" },
-      });
-
-      // Group by workspace → project
-      type CompletedTask = { id: string; title: string; priority: string; completedAt: string };
-      type InProgressTask = { id: string; title: string; status: string; priority: string; lastActivity: string; progressSummary: string | null };
-      type ProjectEntry = { id: string; name: string; alias: string | null; completed: CompletedTask[]; inProgress: InProgressTask[] };
-      type WsEntry = { id: string; name: string; projects: Map<string, ProjectEntry> };
-
-      const wsMap = new Map<string, WsEntry>();
-
-      for (const task of tasks) {
-        const ws = task.project.workspace;
-        if (!wsMap.has(ws.id)) {
-          wsMap.set(ws.id, { id: ws.id, name: ws.name, projects: new Map() });
-        }
-        const projMap = wsMap.get(ws.id)!.projects;
-        const proj = task.project;
-        if (!projMap.has(proj.id)) {
-          projMap.set(proj.id, { id: proj.id, name: proj.name, alias: proj.alias, completed: [], inProgress: [] });
-        }
-        const projEntry = projMap.get(proj.id)!;
-
-        if (task.status === "DONE") {
-          projEntry.completed.push({
-            id: task.id, title: task.title, priority: task.priority,
-            completedAt: task.updatedAt.toISOString(),
-          });
-        } else if (task.status !== "CANCELLED") {
-          projEntry.inProgress.push({
-            id: task.id, title: task.title, status: task.status, priority: task.priority,
-            lastActivity: (task.messages[0]?.createdAt ?? task.updatedAt).toISOString(),
-            progressSummary: task.executions[0]?.summary
-              ?? (task.messages[0]?.content
-                ? task.messages[0].content.slice(0, 200) + (task.messages[0].content.length > 200 ? "..." : "")
-                : null),
-          });
-        }
-      }
-
-      // Query session-insight notes created that day
-      const insightNotes = await db.projectNote.findMany({
-        where: {
-          category: "session-insight",
-          createdAt: { gte: date, lt: nextDay },
-        },
-        include: {
-          project: {
-            include: { workspace: true },
-          },
-          task: { select: { id: true, title: true } },
-        },
-        orderBy: { createdAt: "desc" },
-      });
-
-      const insights = insightNotes.map((note) => ({
-        id: note.id,
-        title: note.title,
-        content: note.content.slice(0, 500),
-        createdAt: note.createdAt.toISOString(),
-        workspace: { id: note.project.workspace.id, name: note.project.workspace.name },
-        project: { id: note.project.id, name: note.project.name, alias: note.project.alias },
-        task: note.task ? { id: note.task.id, title: note.task.title } : null,
-      }));
-
-      let totalCompleted = 0;
-      let totalInProgress = 0;
-      const workspaces = Array.from(wsMap.values()).map((ws) => ({
-        id: ws.id, name: ws.name,
-        projects: Array.from(ws.projects.values()).map((p) => {
-          totalCompleted += p.completed.length;
-          totalInProgress += p.inProgress.length;
-          return { id: p.id, name: p.name, alias: p.alias, completed: p.completed, inProgress: p.inProgress };
-        }),
-      }));
-
-      return {
-        date: date.toISOString().slice(0, 10),
-        workspaces,
-        stats: { totalCompleted, totalInProgress, totalActive: totalCompleted + totalInProgress },
-        insights,
-        insightCount: insights.length,
-      };
-    },
-  },
-
-  daily_todo: {
-    description:
-      "Get all pending tasks (TODO, IN_PROGRESS, IN_REVIEW) across all workspaces, grouped by workspace → project. Supports filtering by workspace, project, status, and priority. Sorted by priority severity (CRITICAL first). Returns lastSessionId for resuming tasks.",
-    schema: z.object({
-      workspaceId: z.string().optional().describe("Filter by workspace ID"),
-      projectId: z.string().optional().describe("Filter by project ID"),
-      status: z.array(z.enum(["TODO", "IN_PROGRESS", "IN_REVIEW"])).optional()
-        .describe("Filter by status. Defaults to all three."),
-      priority: z.array(z.enum(["LOW", "MEDIUM", "HIGH", "CRITICAL"])).optional()
-        .describe("Filter by priority levels"),
-    }),
-    handler: async (args: {
-      workspaceId?: string;
-      projectId?: string;
-      status?: ("TODO" | "IN_PROGRESS" | "IN_REVIEW")[];
-      priority?: ("LOW" | "MEDIUM" | "HIGH" | "CRITICAL")[];
-    }) => {
-      const statusFilter = args.status ?? ["TODO", "IN_PROGRESS", "IN_REVIEW"];
-
-      // eslint-disable-next-line @typescript-eslint/no-explicit-any
-      const where: any = {
-        status: { in: statusFilter },
-        // Exclude system tasks tagged with the builtin "Tower" label
-        NOT: { labels: { some: { label: { name: "Tower", isBuiltin: true } } } },
-      };
-      if (args.priority) where.priority = { in: args.priority };
-      if (args.projectId) where.projectId = args.projectId;
-      if (args.workspaceId) where.project = { workspaceId: args.workspaceId };
-
-      const tasks = await db.task.findMany({
-        where,
-        include: {
-          project: { include: { workspace: true } },
-          labels: { include: { label: true } },
-          executions: {
-            where: { sessionId: { not: null } },
-            orderBy: { createdAt: "desc" },
-            take: 1,
-            select: { sessionId: true },
-          },
-        },
-      });
-
-      // Sort by priority severity (CRITICAL first), then by updatedAt desc
-      tasks.sort((a, b) =>
-        (PRIORITY_ORDER[a.priority] ?? 99) - (PRIORITY_ORDER[b.priority] ?? 99)
-        || b.updatedAt.getTime() - a.updatedAt.getTime()
-      );
-
-      // Group by workspace → project
-      type FormattedTask = { id: string; title: string; status: string; priority: string; labels: string[]; createdAt: string; lastSessionId: string | null };
-      type ProjEntry = { id: string; name: string; alias: string | null; tasks: FormattedTask[] };
-      type WsEntry = { id: string; name: string; projects: Map<string, ProjEntry> };
-
-      const wsMap = new Map<string, WsEntry>();
-
-      for (const task of tasks) {
-        const ws = task.project.workspace;
-        if (!wsMap.has(ws.id)) wsMap.set(ws.id, { id: ws.id, name: ws.name, projects: new Map() });
-        const projMap = wsMap.get(ws.id)!.projects;
-        const proj = task.project;
-        if (!projMap.has(proj.id)) projMap.set(proj.id, { id: proj.id, name: proj.name, alias: proj.alias, tasks: [] });
-        projMap.get(proj.id)!.tasks.push({
-          id: task.id, title: task.title, status: task.status, priority: task.priority,
-          labels: task.labels.map((tl) => tl.label.name),
-          createdAt: task.createdAt.toISOString(),
-          lastSessionId: task.executions[0]?.sessionId ?? null,
-        });
-      }
-
-      const byStatus = { TODO: 0, IN_PROGRESS: 0, IN_REVIEW: 0 };
-      const byPriority = { CRITICAL: 0, HIGH: 0, MEDIUM: 0, LOW: 0 };
-      for (const t of tasks) {
-        if (t.status in byStatus) byStatus[t.status as keyof typeof byStatus]++;
-        if (t.priority in byPriority) byPriority[t.priority as keyof typeof byPriority]++;
-      }
-
-      return {
-        date: new Date().toISOString().slice(0, 10),
-        workspaces: Array.from(wsMap.values()).map((ws) => ({
-          id: ws.id, name: ws.name,
-          projects: Array.from(ws.projects.values()).map((p) => ({
-            id: p.id, name: p.name, alias: p.alias, tasks: p.tasks,
-          })),
-        })),
-        stats: { total: tasks.length, byStatus, byPriority },
-      };
-    },
-  },
-};

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

@@ -1,32 +0,0 @@
-import { z } from "zod";
-import { search, type SearchCategory } from "@/lib/search";
-import { readConfigValue } from "@/lib/config-reader";
-
-export const searchTools = {
-  search: {
-    description:
-      "Search for tasks, projects, repositories, notes, or assets by a query string. Use category 'all' to search across all types.",
-    schema: z.object({
-      query: z.string(),
-      category: z
-        .enum(["task", "project", "repository", "note", "asset", "all"])
-        .default("task")
-        .optional(),
-    }),
-    handler: async (args: {
-      query: string;
-      category?: SearchCategory;
-    }) => {
-      const [resultLimit, allModeCap, snippetLength] = await Promise.all([
-        readConfigValue<number>("search.resultLimit", 20),
-        readConfigValue<number>("search.allModeCap", 5),
-        readConfigValue<number>("search.snippetLength", 80),
-      ]);
-      return search(args.query, args.category ?? "task", {
-        resultLimit,
-        allModeCap,
-        snippetLength,
-      });
-    },
-  },
-};