tower-studio 0.1.2 → 0.1.3

package/.next/standalone/tower/src/mcp/index.ts

@@ -1,15 +0,0 @@
-import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
-import { createServer } from "./server";
-import { initDb } from "./db";
-
-async function main() {
-  await initDb();
-  const server = createServer();
-  const transport = new StdioServerTransport();
-  await server.connect(transport);
-}
-
-main().catch((error) => {
-  console.error("MCP Server failed to start:", error);
-  process.exit(1);
-});

package/.next/standalone/tower/src/mcp/server.ts

@@ -1,52 +0,0 @@
-import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
-import { workspaceTools } from "./tools/workspace-tools";
-import { projectTools } from "./tools/project-tools";
-import { taskTools } from "./tools/task-tools";
-import { labelTools } from "./tools/label-tools";
-import { searchTools } from "./tools/search-tools";
-import { knowledgeTools } from "./tools/knowledge-tools";
-import { noteAssetTools } from "./tools/note-asset-tools";
-import { terminalTools } from "./tools/terminal-tools";
-import { reportTools } from "./tools/report-tools";
-
-export function createServer(): McpServer {
-  const server = new McpServer({ name: "tower", version: "0.1.0" });
-
-  const allTools = {
-    ...workspaceTools,
-    ...projectTools,
-    ...taskTools,
-    ...labelTools,
-    ...searchTools,
-    ...knowledgeTools,
-    ...noteAssetTools,
-    ...terminalTools,
-    ...reportTools,
-  };
-
-  for (const [name, tool] of Object.entries(allTools)) {
-    server.tool(
-      name,
-      tool.description,
-      tool.schema.shape,
-      async (args: Record<string, unknown>) => {
-        try {
-          // eslint-disable-next-line @typescript-eslint/no-explicit-any
-          const result = await (tool.handler as (args: any) => Promise<unknown>)(args);
-          return {
-            content: [{ type: "text" as const, text: JSON.stringify(result, null, 2) }],
-          };
-        } catch (error) {
-          const errorMessage =
-            error instanceof Error ? error.message : String(error);
-          return {
-            isError: true,
-            content: [{ type: "text" as const, text: errorMessage }],
-          };
-        }
-      }
-    );
-  }
-
-  return server;
-}

package/.next/standalone/tower/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/.next/standalone/tower/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 };
-    },
-  },
-};

package/.next/standalone/tower/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/.next/standalone/tower/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 };
-    },
-  },
-};