@vibetasks/mcp-server 0.1.0

package/dist/index.js

@@ -0,0 +1,565 @@
+#!/usr/bin/env node
+
+// src/index.ts
+import { Server } from "@modelcontextprotocol/sdk/server/index.js";
+import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
+import {
+  CallToolRequestSchema,
+  ListToolsRequestSchema,
+  ListResourcesRequestSchema,
+  ReadResourceRequestSchema
+} from "@modelcontextprotocol/sdk/types.js";
+import { AuthManager, TaskOperations } from "@vibetasks/core";
+
+// src/tools/index.ts
+import { z } from "zod";
+function setupTools(taskOps) {
+  return [
+    // create_task
+    {
+      name: "create_task",
+      description: "Create a new task in TaskFlow. Can optionally be a subtask by providing parent_task_id.",
+      inputSchema: z.object({
+        title: z.string().describe("Task title (required)"),
+        notes: z.string().optional().describe("Task notes in markdown"),
+        due_date: z.string().optional().describe("Due date (ISO 8601 format)"),
+        priority: z.enum(["none", "low", "medium", "high"]).default("none").describe("Task priority"),
+        tags: z.array(z.string()).optional().describe("Tag names to attach"),
+        parent_task_id: z.string().optional().describe("Parent task ID to create this as a subtask")
+      }),
+      handler: async (args, taskOps2) => {
+        let tagIds = [];
+        if (args.tags && args.tags.length > 0) {
+          for (const tagName of args.tags) {
+            const tag = await taskOps2.findOrCreateTag(tagName);
+            tagIds.push(tag.id);
+          }
+        }
+        const task = await taskOps2.createTask({
+          title: args.title,
+          notes: args.notes,
+          notes_format: "markdown",
+          due_date: args.due_date,
+          priority: args.priority,
+          parent_task_id: args.parent_task_id
+        });
+        if (tagIds.length > 0) {
+          await taskOps2.linkTaskTags(task.id, tagIds);
+        }
+        return {
+          content: [
+            {
+              type: "text",
+              text: JSON.stringify(
+                {
+                  success: true,
+                  task: {
+                    id: task.id,
+                    title: task.title,
+                    priority: task.priority,
+                    due_date: task.due_date,
+                    parent_task_id: task.parent_task_id,
+                    created_at: task.created_at
+                  }
+                },
+                null,
+                2
+              )
+            }
+          ]
+        };
+      }
+    },
+    // get_tasks
+    {
+      name: "get_tasks",
+      description: "Get tasks by filter",
+      inputSchema: z.object({
+        filter: z.enum(["all", "today", "upcoming", "completed"]).default("all").describe("Task filter")
+      }),
+      handler: async (args, taskOps2) => {
+        const tasks = await taskOps2.getTasks(args.filter);
+        return {
+          content: [
+            {
+              type: "text",
+              text: JSON.stringify(
+                {
+                  success: true,
+                  tasks: tasks.map((t) => ({
+                    id: t.id,
+                    title: t.title,
+                    priority: t.priority,
+                    completed: t.completed,
+                    due_date: t.due_date,
+                    tags: t.tags?.map((tag) => tag.name) || []
+                  })),
+                  count: tasks.length
+                },
+                null,
+                2
+              )
+            }
+          ]
+        };
+      }
+    },
+    // update_task
+    {
+      name: "update_task",
+      description: "Update an existing task",
+      inputSchema: z.object({
+        task_id: z.string().describe("Task ID"),
+        title: z.string().optional().describe("New title"),
+        notes: z.string().optional().describe("New notes"),
+        due_date: z.string().optional().describe("New due date (ISO 8601)"),
+        priority: z.enum(["none", "low", "medium", "high"]).optional().describe("New priority"),
+        completed: z.boolean().optional().describe("Completion status")
+      }),
+      handler: async (args, taskOps2) => {
+        const updates = {};
+        if (args.title !== void 0) updates.title = args.title;
+        if (args.notes !== void 0) updates.notes = args.notes;
+        if (args.due_date !== void 0) updates.due_date = args.due_date;
+        if (args.priority !== void 0) updates.priority = args.priority;
+        if (args.completed !== void 0) updates.completed = args.completed;
+        const task = await taskOps2.updateTask(args.task_id, updates);
+        return {
+          content: [
+            {
+              type: "text",
+              text: JSON.stringify(
+                {
+                  success: true,
+                  task: {
+                    id: task.id,
+                    title: task.title,
+                    completed: task.completed,
+                    priority: task.priority
+                  }
+                },
+                null,
+                2
+              )
+            }
+          ]
+        };
+      }
+    },
+    // complete_task
+    {
+      name: "complete_task",
+      description: "Mark a task as complete",
+      inputSchema: z.object({
+        task_id: z.string().describe("Task ID")
+      }),
+      handler: async (args, taskOps2) => {
+        const task = await taskOps2.completeTask(args.task_id);
+        return {
+          content: [
+            {
+              type: "text",
+              text: JSON.stringify(
+                {
+                  success: true,
+                  task: {
+                    id: task.id,
+                    title: task.title,
+                    completed: true,
+                    completed_at: task.completed_at
+                  }
+                },
+                null,
+                2
+              )
+            }
+          ]
+        };
+      }
+    },
+    // delete_task
+    {
+      name: "delete_task",
+      description: "Delete a task",
+      inputSchema: z.object({
+        task_id: z.string().describe("Task ID")
+      }),
+      handler: async (args, taskOps2) => {
+        await taskOps2.deleteTask(args.task_id);
+        return {
+          content: [
+            {
+              type: "text",
+              text: JSON.stringify(
+                {
+                  success: true,
+                  message: "Task deleted successfully"
+                },
+                null,
+                2
+              )
+            }
+          ]
+        };
+      }
+    },
+    // search_tasks
+    {
+      name: "search_tasks",
+      description: "Search tasks by title",
+      inputSchema: z.object({
+        query: z.string().describe("Search query"),
+        limit: z.number().default(20).describe("Maximum results")
+      }),
+      handler: async (args, taskOps2) => {
+        const tasks = await taskOps2.searchTasks(args.query, args.limit);
+        return {
+          content: [
+            {
+              type: "text",
+              text: JSON.stringify(
+                {
+                  success: true,
+                  tasks: tasks.map((t) => ({
+                    id: t.id,
+                    title: t.title,
+                    priority: t.priority,
+                    due_date: t.due_date,
+                    tags: t.tags?.map((tag) => tag.name) || []
+                  })),
+                  count: tasks.length
+                },
+                null,
+                2
+              )
+            }
+          ]
+        };
+      }
+    },
+    // create_task_with_subtasks
+    {
+      name: "create_task_with_subtasks",
+      description: "Create a parent task with multiple subtasks in one call. Use this when using TodoWrite - it automatically mirrors your todo list to TaskFlow for persistent tracking.",
+      inputSchema: z.object({
+        title: z.string().describe("Parent task title (the overall goal)"),
+        subtasks: z.array(z.string()).describe("Array of subtask titles (one for each todo item)"),
+        notes: z.string().optional().describe("Notes for parent task"),
+        due_date: z.string().optional().describe("Due date for parent task (ISO 8601 format)"),
+        priority: z.enum(["none", "low", "medium", "high"]).default("none").describe("Priority for parent task"),
+        tags: z.array(z.string()).optional().describe("Tag names to attach to parent task")
+      }),
+      handler: async (args, taskOps2) => {
+        let tagIds = [];
+        if (args.tags && args.tags.length > 0) {
+          for (const tagName of args.tags) {
+            const tag = await taskOps2.findOrCreateTag(tagName);
+            tagIds.push(tag.id);
+          }
+        }
+        const parentTask = await taskOps2.createTask({
+          title: args.title,
+          notes: args.notes,
+          notes_format: "markdown",
+          due_date: args.due_date,
+          priority: args.priority
+        });
+        if (tagIds.length > 0) {
+          await taskOps2.linkTaskTags(parentTask.id, tagIds);
+        }
+        const subtasks = [];
+        for (const subtaskTitle of args.subtasks) {
+          const subtask = await taskOps2.createTask({
+            title: subtaskTitle,
+            notes_format: "markdown",
+            priority: "none",
+            parent_task_id: parentTask.id
+          });
+          subtasks.push(subtask);
+        }
+        return {
+          content: [
+            {
+              type: "text",
+              text: JSON.stringify(
+                {
+                  success: true,
+                  parent_task: {
+                    id: parentTask.id,
+                    title: parentTask.title,
+                    priority: parentTask.priority,
+                    subtask_count: subtasks.length
+                  },
+                  subtasks: subtasks.map((s) => ({
+                    id: s.id,
+                    title: s.title
+                  }))
+                },
+                null,
+                2
+              )
+            }
+          ]
+        };
+      }
+    },
+    // log_ai_session
+    {
+      name: "log_ai_session",
+      description: "Manually log an AI session as a completed task",
+      inputSchema: z.object({
+        summary: z.string().describe("What was accomplished"),
+        files: z.array(z.string()).optional().describe("Files changed"),
+        duration_minutes: z.number().optional().describe("Session duration")
+      }),
+      handler: async (args, taskOps2) => {
+        const notes = `# AI Session Summary
+
+${args.summary}
+
+${args.files && args.files.length > 0 ? `## Files Changed
+${args.files.map((f) => `- ${f}`).join("\n")}` : ""}
+
+${args.duration_minutes ? `Duration: ${args.duration_minutes} minutes` : ""}
+
+Generated by TaskFlow MCP Server`;
+        const task = await taskOps2.createTask({
+          title: `AI Session: ${args.summary.substring(0, 50)}${args.summary.length > 50 ? "..." : ""}`,
+          notes,
+          notes_format: "markdown",
+          completed: true,
+          priority: "none"
+        });
+        return {
+          content: [
+            {
+              type: "text",
+              text: JSON.stringify(
+                {
+                  success: true,
+                  task: {
+                    id: task.id,
+                    title: task.title,
+                    completed: true
+                  }
+                },
+                null,
+                2
+              )
+            }
+          ]
+        };
+      }
+    }
+  ];
+}
+
+// src/resources/index.ts
+function setupResources(taskOps) {
+  return [
+    // Active tasks resource
+    {
+      uri: "taskflow://tasks/active",
+      name: "Active Tasks",
+      description: "All incomplete tasks",
+      mimeType: "application/json",
+      handler: async (taskOps2) => {
+        const tasks = await taskOps2.getTasks("all");
+        return {
+          contents: [
+            {
+              uri: "taskflow://tasks/active",
+              mimeType: "application/json",
+              text: JSON.stringify(
+                {
+                  tasks: tasks.map((t) => ({
+                    id: t.id,
+                    title: t.title,
+                    priority: t.priority,
+                    due_date: t.due_date,
+                    tags: t.tags?.map((tag) => tag.name) || []
+                  })),
+                  count: tasks.length
+                },
+                null,
+                2
+              )
+            }
+          ]
+        };
+      }
+    },
+    // Today's tasks resource
+    {
+      uri: "taskflow://tasks/today",
+      name: "Today's Tasks",
+      description: "Tasks due today",
+      mimeType: "application/json",
+      handler: async (taskOps2) => {
+        const tasks = await taskOps2.getTasks("today");
+        return {
+          contents: [
+            {
+              uri: "taskflow://tasks/today",
+              mimeType: "application/json",
+              text: JSON.stringify(
+                {
+                  tasks: tasks.map((t) => ({
+                    id: t.id,
+                    title: t.title,
+                    priority: t.priority,
+                    tags: t.tags?.map((tag) => tag.name) || []
+                  })),
+                  count: tasks.length,
+                  date: (/* @__PURE__ */ new Date()).toISOString().split("T")[0]
+                },
+                null,
+                2
+              )
+            }
+          ]
+        };
+      }
+    },
+    // Upcoming tasks resource
+    {
+      uri: "taskflow://tasks/upcoming",
+      name: "Upcoming Tasks",
+      description: "Tasks due in the future",
+      mimeType: "application/json",
+      handler: async (taskOps2) => {
+        const tasks = await taskOps2.getTasks("upcoming");
+        return {
+          contents: [
+            {
+              uri: "taskflow://tasks/upcoming",
+              mimeType: "application/json",
+              text: JSON.stringify(
+                {
+                  tasks: tasks.map((t) => ({
+                    id: t.id,
+                    title: t.title,
+                    priority: t.priority,
+                    due_date: t.due_date,
+                    tags: t.tags?.map((tag) => tag.name) || []
+                  })),
+                  count: tasks.length
+                },
+                null,
+                2
+              )
+            }
+          ]
+        };
+      }
+    }
+  ];
+}
+
+// src/index.ts
+var hookType = process.env.CLAUDE_HOOK_TYPE;
+if (hookType === "SessionStart") {
+  const { handleSessionStart } = await import("./session-start-OIAJ7YIL.js");
+  await handleSessionStart();
+  process.exit(0);
+} else if (hookType === "SessionEnd" || hookType === "Stop") {
+  const { handleSessionEnd } = await import("./session-end-6BUUHSB7.js");
+  await handleSessionEnd();
+  process.exit(0);
+}
+async function main() {
+  try {
+    const authManager = new AuthManager();
+    const supabaseUrl = process.env.TASKFLOW_SUPABASE_URL || await authManager.getConfig("supabase_url") || "https://cbkkztbcoitrfcleghfd.supabase.co";
+    const supabaseKey = process.env.TASKFLOW_SUPABASE_KEY || await authManager.getConfig("supabase_key") || "eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9.eyJpc3MiOiJzdXBhYmFzZSIsInJlZiI6ImNia2t6dGJjb2l0cmZjbGVnaGZkIiwicm9sZSI6ImFub24iLCJpYXQiOjE3Njc3NTc0MjgsImV4cCI6MjA4MzMzMzQyOH0.G7ILx-nntP0NbxO1gKt5yASb7nt7OmpJ8qtykeGYbQA";
+    const accessToken = await authManager.getAccessToken();
+    if (!accessToken) {
+      console.error("ERROR: Not authenticated.", { severity: "error" });
+      console.error("Run: taskflow login", { severity: "error" });
+      process.exit(1);
+    }
+    if (!accessToken) {
+      console.error("ERROR: Not authenticated.", { severity: "error" });
+      console.error("Run: taskflow login", { severity: "error" });
+      process.exit(1);
+    }
+    const taskOps = await TaskOperations.fromAuthManager(authManager);
+    const server = new Server(
+      {
+        name: "taskflow-mcp-server",
+        version: "1.0.0"
+      },
+      {
+        capabilities: {
+          tools: {},
+          resources: {}
+        }
+      }
+    );
+    const tools = setupTools(taskOps);
+    const resources = setupResources(taskOps);
+    server.setRequestHandler(ListToolsRequestSchema, async () => {
+      return {
+        tools: tools.map((t) => ({
+          name: t.name,
+          description: t.description,
+          inputSchema: t.inputSchema
+        }))
+      };
+    });
+    server.setRequestHandler(CallToolRequestSchema, async (request) => {
+      const tool = tools.find((t) => t.name === request.params.name);
+      if (!tool) {
+        throw new Error(`Unknown tool: ${request.params.name}`);
+      }
+      try {
+        return await tool.handler(request.params.arguments || {}, taskOps);
+      } catch (error) {
+        return {
+          content: [
+            {
+              type: "text",
+              text: JSON.stringify(
+                {
+                  success: false,
+                  error: error.message
+                },
+                null,
+                2
+              )
+            }
+          ],
+          isError: true
+        };
+      }
+    });
+    server.setRequestHandler(ListResourcesRequestSchema, async () => {
+      return {
+        resources: resources.map((r) => ({
+          uri: r.uri,
+          name: r.name,
+          description: r.description,
+          mimeType: r.mimeType
+        }))
+      };
+    });
+    server.setRequestHandler(ReadResourceRequestSchema, async (request) => {
+      const resource = resources.find((r) => r.uri === request.params.uri);
+      if (!resource) {
+        throw new Error(`Unknown resource: ${request.params.uri}`);
+      }
+      try {
+        return await resource.handler(taskOps);
+      } catch (error) {
+        throw new Error(`Failed to read resource: ${error.message}`);
+      }
+    });
+    const transport = new StdioServerTransport();
+    await server.connect(transport);
+    console.error("TaskFlow MCP server started", { severity: "info" });
+  } catch (error) {
+    console.error("Fatal error:", error, { severity: "error" });
+    process.exit(1);
+  }
+}
+main();

package/dist/session-end-6BUUHSB7.js

@@ -0,0 +1,56 @@
+// src/hooks/session-end.ts
+import { AuthManager, TaskOperations } from "@vibetasks/core";
+async function handleSessionEnd() {
+  try {
+    const authManager = new AuthManager();
+    const isAuth = await authManager.isAuthenticated();
+    if (!isAuth) {
+      return;
+    }
+    const metadataJson = process.env.CLAUDE_SESSION_METADATA || "{}";
+    const metadata = JSON.parse(metadataJson);
+    const filesEdited = metadata.filesEdited || [];
+    const duration = metadata.duration || 0;
+    const aiActions = metadata.aiActions || [];
+    const shouldLog = filesEdited.length > 0 && duration >= 6e4 && aiActions.length > 0;
+    if (!shouldLog) {
+      console.error("TaskFlow: Session too short, not logging");
+      return;
+    }
+    const taskOps = await TaskOperations.fromAuthManager(authManager);
+    const durationMinutes = Math.round(duration / 6e4);
+    const primaryAction = aiActions[0] || "Code changes";
+    const summary = `# AI Session Completed
+
+## Summary
+${primaryAction}
+
+## Duration
+${durationMinutes} minutes
+
+## Files Edited (${filesEdited.length})
+${filesEdited.slice(0, 15).map((f) => `- ${f}`).join("\n")}
+${filesEdited.length > 15 ? `
+...and ${filesEdited.length - 15} more files` : ""}
+
+## Actions
+${aiActions.map((a) => `- ${a}`).join("\n")}
+
+---
+*Generated by TaskFlow MCP Server*
+`.trim();
+    await taskOps.createTask({
+      title: `AI Session: ${primaryAction}`,
+      notes: summary,
+      notes_format: "markdown",
+      completed: true,
+      priority: "none"
+    });
+    console.error("TaskFlow: Logged AI session as completed task");
+  } catch (error) {
+    console.error("TaskFlow SessionEnd hook error:", error.message);
+  }
+}
+export {
+  handleSessionEnd
+};

package/dist/session-start-OIAJ7YIL.js

@@ -0,0 +1,49 @@
+// src/hooks/session-start.ts
+import { AuthManager, TaskOperations } from "@vibetasks/core";
+async function handleSessionStart() {
+  try {
+    const authManager = new AuthManager();
+    const isAuth = await authManager.isAuthenticated();
+    if (!isAuth) {
+      console.log(JSON.stringify({ additionalContext: "" }));
+      return;
+    }
+    const taskOps = await TaskOperations.fromAuthManager(authManager);
+    const todayTasks = await taskOps.getTasks("today");
+    const activeTasks = await taskOps.getTasks("all");
+    const context = `# TaskFlow - Your Tasks
+
+## Today's Tasks (${todayTasks.length})
+${todayTasks.length === 0 ? "No tasks due today." : todayTasks.map((t) => {
+      const priority = t.priority && t.priority !== "none" ? ` [${t.priority.toUpperCase()}]` : "";
+      const tags = t.tags && t.tags.length > 0 ? ` #${t.tags.map((tag) => tag.name).join(" #")}` : "";
+      return `- [ ] ${t.title}${priority}${tags}`;
+    }).join("\n")}
+
+## All Active Tasks (${activeTasks.length})
+${activeTasks.length === 0 ? "No active tasks." : activeTasks.slice(0, 10).map((t) => {
+      const priority = t.priority && t.priority !== "none" ? ` [${t.priority.toUpperCase()}]` : "";
+      const dueDate = t.due_date ? ` (Due: ${t.due_date.split("T")[0]})` : "";
+      return `- [ ] ${t.title}${priority}${dueDate}`;
+    }).join("\n")}${activeTasks.length > 10 ? `
+...and ${activeTasks.length - 10} more` : ""}
+
+---
+You can manage tasks using these MCP tools:
+- create_task: Add new tasks
+- get_tasks: View tasks by filter
+- complete_task: Mark tasks done
+- search_tasks: Find tasks
+- update_task: Modify tasks
+- delete_task: Remove tasks
+- log_ai_session: Log what we accomplish together
+`.trim();
+    console.log(JSON.stringify({ additionalContext: context }));
+  } catch (error) {
+    console.error("TaskFlow SessionStart hook error:", error.message);
+    console.log(JSON.stringify({ additionalContext: "" }));
+  }
+}
+export {
+  handleSessionStart
+};

package/package.json

@@ -0,0 +1,29 @@
+{
+  "name": "@vibetasks/mcp-server",
+  "version": "0.1.0",
+  "description": "VibeTasks MCP Server for Claude Code and other AI coding tools",
+  "type": "module",
+  "bin": {
+    "vibetasks-mcp": "./dist/index.js"
+  },
+  "scripts": {
+    "dev": "tsx src/index.ts",
+    "build": "tsup src/index.ts --format esm --clean --outDir dist --shims",
+    "start": "node dist/index.js",
+    "typecheck": "tsc --noEmit"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "dependencies": {
+    "@modelcontextprotocol/sdk": "^0.5.0",
+    "@vibetasks/core": "^0.1.0",
+    "zod": "^3.22.0"
+  },
+  "devDependencies": {
+    "@types/node": "^20.0.0",
+    "tsx": "^4.7.0",
+    "tsup": "^8.0.0",
+    "typescript": "^5.3.3"
+  }
+}