project-tree-mindev188-mcp 0.0.1

package/dist/index.js

@@ -0,0 +1,357 @@
+#!/usr/bin/env node
+"use strict";
+
+// src/index.ts
+var import_stdio = require("@modelcontextprotocol/sdk/server/stdio.js");
+
+// src/server.ts
+var import_mcp = require("@modelcontextprotocol/sdk/server/mcp.js");
+var import_zod = require("zod");
+var import_db = require("@project-tree/db");
+function createMcpServer() {
+  const server = new import_mcp.McpServer({
+    name: "project-tree",
+    version: "0.0.1"
+  });
+  server.tool(
+    "get_next_tasks",
+    "Get the next tasks to work on, filtered by project, assignee, or status",
+    {
+      project_id: import_zod.z.string().uuid().optional().describe("Filter by project ID"),
+      assignee: import_zod.z.string().optional().describe("Filter by assignee ID"),
+      status: import_zod.z.array(import_zod.z.enum(["backlog", "todo", "in_progress", "review", "done"])).optional().describe("Filter by status(es)"),
+      limit: import_zod.z.number().int().min(1).max(100).optional().describe("Max results (default 10)")
+    },
+    async ({ project_id, assignee, status, limit }) => {
+      const tasks = await (0, import_db.listTasks)({
+        projectId: project_id,
+        assigneeId: assignee,
+        status,
+        limit: limit ?? 10
+      });
+      return {
+        content: [
+          {
+            type: "text",
+            text: JSON.stringify(tasks, null, 2)
+          }
+        ]
+      };
+    }
+  );
+  server.tool(
+    "update_progress",
+    "Update the progress of a task (status, notes, completion percentage)",
+    {
+      task_id: import_zod.z.string().uuid().describe("Task ID to update"),
+      status: import_zod.z.enum(["backlog", "todo", "in_progress", "review", "done"]).optional().describe("New status"),
+      note: import_zod.z.string().optional().describe("Progress note"),
+      progress_pct: import_zod.z.number().min(0).max(100).optional().describe("Completion percentage")
+    },
+    async ({ task_id, status, note, progress_pct }) => {
+      const updated = await (0, import_db.updateTask)(task_id, {
+        status,
+        note,
+        progressPct: progress_pct
+      });
+      if (!updated) {
+        return {
+          content: [{ type: "text", text: `Task ${task_id} not found` }],
+          isError: true
+        };
+      }
+      await (0, import_db.createActivity)({
+        projectId: updated.projectId,
+        action: "update_progress",
+        entityType: "task",
+        entityId: task_id,
+        metadata: { status, note, progress_pct },
+        source: "mcp"
+      });
+      return {
+        content: [
+          {
+            type: "text",
+            text: JSON.stringify(updated, null, 2)
+          }
+        ]
+      };
+    }
+  );
+  server.tool(
+    "add_item",
+    "Add a new task, note, or document to a project",
+    {
+      type: import_zod.z.enum(["task", "note", "document"]).describe("Item type to create"),
+      project_id: import_zod.z.string().uuid().describe("Project ID"),
+      title: import_zod.z.string().describe("Item title"),
+      content: import_zod.z.string().optional().describe("Item content/description"),
+      priority: import_zod.z.number().int().min(1).max(5).optional().describe("Priority (tasks only, 1-5)"),
+      labels: import_zod.z.array(import_zod.z.string()).optional().describe("Labels (tasks only)"),
+      tags: import_zod.z.array(import_zod.z.string()).optional().describe("Tags (documents only)"),
+      doc_type: import_zod.z.enum(["note", "doc", "spec", "adr"]).optional().describe("Document type")
+    },
+    async ({ type, project_id, title, content, priority, labels, tags, doc_type }) => {
+      let result;
+      if (type === "task") {
+        result = await (0, import_db.createTask)({
+          projectId: project_id,
+          title,
+          description: content,
+          priority: priority ?? 3,
+          labels: labels ?? []
+        });
+        await (0, import_db.createActivity)({
+          projectId: project_id,
+          action: "create",
+          entityType: "task",
+          entityId: result.id,
+          metadata: { title, priority },
+          source: "mcp"
+        });
+      } else {
+        result = await (0, import_db.createDocument)({
+          projectId: project_id,
+          title,
+          content: content ?? "",
+          type: doc_type ?? (type === "note" ? "note" : "doc"),
+          tags: tags ?? []
+        });
+        await (0, import_db.createActivity)({
+          projectId: project_id,
+          action: "create",
+          entityType: "document",
+          entityId: result.id,
+          metadata: { title, type: doc_type ?? type },
+          source: "mcp"
+        });
+      }
+      return {
+        content: [
+          {
+            type: "text",
+            text: JSON.stringify(result, null, 2)
+          }
+        ]
+      };
+    }
+  );
+  server.tool(
+    "get_project_overview",
+    "Get a comprehensive overview of a project including repos, task summary, and recent activity",
+    {
+      project_id: import_zod.z.string().uuid().describe("Project ID")
+    },
+    async ({ project_id }) => {
+      const project = await (0, import_db.getProject)(project_id);
+      if (!project) {
+        return {
+          content: [{ type: "text", text: `Project ${project_id} not found` }],
+          isError: true
+        };
+      }
+      const [repos, allTasks, activities] = await Promise.all([
+        (0, import_db.listRepositories)(project_id),
+        (0, import_db.listTasks)({ projectId: project_id, limit: 1e3 }),
+        (0, import_db.listActivities)(project_id, 10)
+      ]);
+      const taskSummary = {
+        total: allTasks.length,
+        byStatus: {
+          backlog: allTasks.filter((t) => t.status === "backlog").length,
+          todo: allTasks.filter((t) => t.status === "todo").length,
+          in_progress: allTasks.filter((t) => t.status === "in_progress").length,
+          review: allTasks.filter((t) => t.status === "review").length,
+          done: allTasks.filter((t) => t.status === "done").length
+        }
+      };
+      const overview = {
+        project,
+        repositories: repos,
+        taskSummary,
+        recentActivity: activities
+      };
+      return {
+        content: [
+          {
+            type: "text",
+            text: JSON.stringify(overview, null, 2)
+          }
+        ]
+      };
+    }
+  );
+  server.tool(
+    "search_docs",
+    "Search documents by content with optional filters",
+    {
+      query: import_zod.z.string().describe("Search query"),
+      project_id: import_zod.z.string().uuid().optional().describe("Filter by project"),
+      type: import_zod.z.enum(["note", "doc", "spec", "adr"]).optional().describe("Filter by document type"),
+      limit: import_zod.z.number().int().min(1).max(50).optional().describe("Max results")
+    },
+    async ({ query, project_id, type, limit }) => {
+      const results = await (0, import_db.searchDocuments)({
+        query,
+        projectId: project_id,
+        type,
+        limit
+      });
+      return {
+        content: [
+          {
+            type: "text",
+            text: JSON.stringify(results, null, 2)
+          }
+        ]
+      };
+    }
+  );
+  server.tool(
+    "delete_task",
+    "Delete a task by ID",
+    {
+      task_id: import_zod.z.string().uuid().describe("Task ID to delete")
+    },
+    async ({ task_id }) => {
+      const existing = await (0, import_db.listTasks)({ limit: 1e3 });
+      const task = existing.find((t) => t.id === task_id);
+      if (!task) {
+        return {
+          content: [{ type: "text", text: `Task ${task_id} not found` }],
+          isError: true
+        };
+      }
+      await (0, import_db.deleteTask)(task_id);
+      await (0, import_db.createActivity)({
+        projectId: task.projectId,
+        action: "delete",
+        entityType: "task",
+        entityId: task_id,
+        metadata: { title: task.title },
+        source: "mcp"
+      });
+      return {
+        content: [{ type: "text", text: `Task ${task_id} deleted` }]
+      };
+    }
+  );
+  server.tool(
+    "update_document",
+    "Update a document's title, content, type, or tags",
+    {
+      doc_id: import_zod.z.string().uuid().describe("Document ID to update"),
+      title: import_zod.z.string().optional().describe("New title"),
+      content: import_zod.z.string().optional().describe("New content"),
+      type: import_zod.z.enum(["note", "doc", "spec", "adr"]).optional().describe("New document type"),
+      tags: import_zod.z.array(import_zod.z.string()).optional().describe("New tags (replaces existing)")
+    },
+    async ({ doc_id, title, content, type, tags }) => {
+      const updated = await (0, import_db.updateDocument)(doc_id, { title, content, type, tags });
+      if (!updated) {
+        return {
+          content: [{ type: "text", text: `Document ${doc_id} not found` }],
+          isError: true
+        };
+      }
+      await (0, import_db.createActivity)({
+        projectId: updated.projectId,
+        action: "update",
+        entityType: "document",
+        entityId: doc_id,
+        metadata: { title, type },
+        source: "mcp"
+      });
+      return {
+        content: [{ type: "text", text: JSON.stringify(updated, null, 2) }]
+      };
+    }
+  );
+  server.tool(
+    "delete_document",
+    "Delete a document by ID",
+    {
+      doc_id: import_zod.z.string().uuid().describe("Document ID to delete")
+    },
+    async ({ doc_id }) => {
+      const existing = await (0, import_db.getDocument)(doc_id);
+      if (!existing) {
+        return {
+          content: [{ type: "text", text: `Document ${doc_id} not found` }],
+          isError: true
+        };
+      }
+      await (0, import_db.deleteDocument)(doc_id);
+      await (0, import_db.createActivity)({
+        projectId: existing.projectId,
+        action: "delete",
+        entityType: "document",
+        entityId: doc_id,
+        metadata: { title: existing.title },
+        source: "mcp"
+      });
+      return {
+        content: [{ type: "text", text: `Document ${doc_id} deleted` }]
+      };
+    }
+  );
+  server.tool(
+    "list_projects",
+    "List all projects",
+    {},
+    async () => {
+      const projects = await (0, import_db.listProjects)();
+      return {
+        content: [{ type: "text", text: JSON.stringify(projects, null, 2) }]
+      };
+    }
+  );
+  server.tool(
+    "get_document",
+    "Get full content of a document by ID",
+    {
+      doc_id: import_zod.z.string().uuid().describe("Document ID")
+    },
+    async ({ doc_id }) => {
+      const doc = await (0, import_db.getDocument)(doc_id);
+      if (!doc) {
+        return {
+          content: [{ type: "text", text: `Document ${doc_id} not found` }],
+          isError: true
+        };
+      }
+      return {
+        content: [{ type: "text", text: JSON.stringify(doc, null, 2) }]
+      };
+    }
+  );
+  server.tool(
+    "list_documents",
+    "List documents with optional filters by project or type",
+    {
+      project_id: import_zod.z.string().uuid().optional().describe("Filter by project ID"),
+      type: import_zod.z.enum(["note", "doc", "spec", "adr"]).optional().describe("Filter by document type")
+    },
+    async ({ project_id, type }) => {
+      const docs = await (0, import_db.listDocuments)({ projectId: project_id, type });
+      return {
+        content: [{ type: "text", text: JSON.stringify(docs, null, 2) }]
+      };
+    }
+  );
+  return server;
+}
+
+// src/index.ts
+var import_db2 = require("@project-tree/db");
+async function main() {
+  (0, import_db2.runMigrations)();
+  const server = createMcpServer();
+  const transport = new import_stdio.StdioServerTransport();
+  await server.connect(transport);
+  console.error("ProjectTree MCP server running on stdio");
+}
+main().catch((err) => {
+  console.error("Fatal error:", err);
+  process.exit(1);
+});

package/package.json

@@ -0,0 +1,32 @@
+{
+  "name": "project-tree-mindev188-mcp",
+  "version": "0.0.1",
+  "main": "dist/index.js",
+  "bin": {
+    "project-tree-mcp": "dist/index.js"
+  },
+  "files": [
+    "dist"
+  ],
+  "publishConfig": {
+    "access": "public"
+  },
+  "scripts": {
+    "build": "tsup",
+    "dev": "tsx watch src/index.ts",
+    "start": "tsx src/index.ts",
+    "clean": "rm -rf dist"
+  },
+  "dependencies": {
+    "@modelcontextprotocol/sdk": "^1.12.0",
+    "@project-tree/db": "workspace:*",
+    "@project-tree/shared": "workspace:*",
+    "simple-git": "^3.27.0",
+    "zod": "^3.24.0"
+  },
+  "devDependencies": {
+    "tsup": "^8.5.1",
+    "tsx": "^4.19.0",
+    "typescript": "^5.7.0"
+  }
+}