@vibetasks/mcp-server 0.1.0 → 0.2.2

package/src/resources/index.ts

@@ -1,115 +0,0 @@
-import { TaskOperations } from '@vibetasks/core';
-
-export interface MCPResource {
-  uri: string;
-  name: string;
-  description: string;
-  mimeType: string;
-  handler: (taskOps: TaskOperations) => Promise<any>;
-}
-
-export function setupResources(taskOps: TaskOperations): MCPResource[] {
-  return [
-    // Active tasks resource
-    {
-      uri: 'taskflow://tasks/active',
-      name: 'Active Tasks',
-      description: 'All incomplete tasks',
-      mimeType: 'application/json',
-      handler: async (taskOps) => {
-        const tasks = await taskOps.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 (taskOps) => {
-        const tasks = await taskOps.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: 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 (taskOps) => {
-        const tasks = await taskOps.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
-              ),
-            },
-          ],
-        };
-      },
-    },
-  ];
-}

package/src/tools/index.ts

@@ -1,414 +0,0 @@
-import { TaskOperations } from '@vibetasks/core';
-import { z } from 'zod';
-
-export interface MCPTool {
-  name: string;
-  description: string;
-  inputSchema: z.ZodType<any>;
-  handler: (args: any, taskOps: TaskOperations) => Promise<any>;
-}
-
-export function setupTools(taskOps: TaskOperations): MCPTool[] {
-  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, taskOps) => {
-        // Handle tags - get or create
-        let tagIds: string[] = [];
-        if (args.tags && args.tags.length > 0) {
-          for (const tagName of args.tags) {
-            const tag = await taskOps.findOrCreateTag(tagName);
-            tagIds.push(tag.id);
-          }
-        }
-
-        // Create task
-        const task = await taskOps.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,
-        });
-
-        // Link tags
-        if (tagIds.length > 0) {
-          await taskOps.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, taskOps) => {
-        const tasks = await taskOps.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, taskOps) => {
-        const updates: any = {};
-
-        if (args.title !== undefined) updates.title = args.title;
-        if (args.notes !== undefined) updates.notes = args.notes;
-        if (args.due_date !== undefined) updates.due_date = args.due_date;
-        if (args.priority !== undefined) updates.priority = args.priority;
-        if (args.completed !== undefined) updates.completed = args.completed;
-
-        const task = await taskOps.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, taskOps) => {
-        const task = await taskOps.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, taskOps) => {
-        await taskOps.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, taskOps) => {
-        const tasks = await taskOps.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, taskOps) => {
-        // Handle tags - get or create
-        let tagIds: string[] = [];
-        if (args.tags && args.tags.length > 0) {
-          for (const tagName of args.tags) {
-            const tag = await taskOps.findOrCreateTag(tagName);
-            tagIds.push(tag.id);
-          }
-        }
-
-        // Create parent task
-        const parentTask = await taskOps.createTask({
-          title: args.title,
-          notes: args.notes,
-          notes_format: 'markdown',
-          due_date: args.due_date,
-          priority: args.priority,
-        });
-
-        // Link tags to parent
-        if (tagIds.length > 0) {
-          await taskOps.linkTaskTags(parentTask.id, tagIds);
-        }
-
-        // Create all subtasks
-        const subtasks = [];
-        for (const subtaskTitle of args.subtasks) {
-          const subtask = await taskOps.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, taskOps) => {
-        const notes = `# AI Session Summary
-
-${args.summary}
-
-${args.files && args.files.length > 0 ? `## Files Changed\n${args.files.map((f) => `- ${f}`).join('\n')}` : ''}
-
-${args.duration_minutes ? `Duration: ${args.duration_minutes} minutes` : ''}
-
-Generated by TaskFlow MCP Server`;
-
-        const task = await taskOps.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
-              ),
-            },
-          ],
-        };
-      },
-    },
-  ];
-}

package/tsconfig.json

@@ -1,21 +0,0 @@
-{
-  "compilerOptions": {
-    "target": "ES2022",
-    "module": "ESNext",
-    "lib": ["ES2022"],
-    "moduleResolution": "bundler",
-    "resolveJsonModule": true,
-    "allowJs": true,
-    "strict": true,
-    "esModuleInterop": true,
-    "skipLibCheck": true,
-    "forceConsistentCasingInFileNames": true,
-    "declaration": true,
-    "declarationMap": true,
-    "outDir": "./dist",
-    "rootDir": "./src",
-    "types": ["node"]
-  },
-  "include": ["src/**/*"],
-  "exclude": ["node_modules", "dist"]
-}