taskman-mcp 0.1.1

package/app.js

@@ -0,0 +1,487 @@
+#!/usr/bin/env node
+import { Server } from '@modelcontextprotocol/sdk/server/index.js';
+import { StdioServerTransport } from '@modelcontextprotocol/sdk/server/stdio.js';
+import { CallToolRequestSchema, ListToolsRequestSchema } from '@modelcontextprotocol/sdk/types.js';
+import fs from 'fs';
+import path from 'path';
+import os from 'os';
+
+const DATA_PATH = path.join(os.homedir(), '.taskman', 'data.json');
+
+function loadStore() {
+  try {
+    if (fs.existsSync(DATA_PATH)) {
+      const store = JSON.parse(fs.readFileSync(DATA_PATH, 'utf8'));
+      migrateStore(store);
+      return store;
+    }
+  } catch (e) {}
+  return { tasks: [], ideas: [], completed_tasks: [], completed_ideas: [] };
+}
+
+function migrateStore(store) {
+  let changed = false;
+  for (const task of (store.tasks || [])) {
+    if (task.notes && !task.content) {
+      task.content = task.notes;
+      delete task.notes;
+      changed = true;
+    }
+    if (!task.status) {
+      task.status = task.completed ? 'completed' : 'pending';
+      changed = true;
+    }
+  }
+  for (const idea of (store.ideas || [])) {
+    if (idea.notes && !idea.content) {
+      idea.content = idea.notes;
+      delete idea.notes;
+      changed = true;
+    }
+    if (!idea.status) {
+      idea.status = 'pending';
+      changed = true;
+    }
+  }
+  if (changed) saveStore(store);
+}
+
+function saveStore(store) {
+  const dir = path.dirname(DATA_PATH);
+  if (!fs.existsSync(dir)) {
+    fs.mkdirSync(dir, { recursive: true });
+  }
+  fs.writeFileSync(DATA_PATH, JSON.stringify(store, null, 2));
+}
+
+function generateId() {
+  const now = new Date();
+  return now.toISOString().replace(/[-:T]/g, '').replace(/\..+/, '') + '.' + String(now.getMilliseconds()).padStart(6, '0');
+}
+
+function getStatusIcon(status) {
+  switch (status) {
+    case 'in_progress': return '◐';
+    case 'completed': return '◉';
+    case 'archived': return '◉';
+    default: return '○';
+  }
+}
+
+function getProgress(task) {
+  if (!task.subtasks || task.subtasks.length === 0) return '';
+  const completed = task.subtasks.filter(s => s.status === 'completed').length;
+  return ` [${completed}/${task.subtasks.length}]`;
+}
+
+const server = new Server(
+  { name: 'taskman-mcp', version: '0.2.0' },
+  { capabilities: { tools: {} } }
+);
+
+server.setRequestHandler(ListToolsRequestSchema, async () => ({
+  tools: [
+    {
+      name: 'mcp__taskman_task_list',
+      description: 'List all tasks. Filter by all, pending, or completed.',
+      inputSchema: {
+        type: 'object',
+        properties: {
+          filter: { type: 'string', description: 'Filter: all, pending, or completed', enum: ['all', 'pending', 'completed'] }
+        }
+      }
+    },
+    {
+      name: 'mcp__taskman_task_get',
+      description: 'Get details of a specific task by ID.',
+      inputSchema: {
+        type: 'object',
+        properties: { id: { type: 'string', description: 'Task ID' } },
+        required: ['id']
+      }
+    },
+    {
+      name: 'mcp__taskman_task_create',
+      description: 'Create a new task.',
+      inputSchema: {
+        type: 'object',
+        properties: {
+          title: { type: 'string', description: 'Task title' },
+          content: { type: 'string', description: 'Task content' },
+          due_date: { type: 'string', description: 'Due date (YYYY-MM-DD)' },
+          reminder: { type: 'string', description: 'Reminder time (YYYY-MM-DD HH:MM)' }
+        },
+        required: ['title']
+      }
+    },
+    {
+      name: 'mcp__taskman_task_toggle',
+      description: 'Toggle task completion status.',
+      inputSchema: {
+        type: 'object',
+        properties: { id: { type: 'string', description: 'Task ID' } },
+        required: ['id']
+      }
+    },
+    {
+      name: 'mcp__taskman_task_update_status',
+      description: 'Update task status (pending, in_progress, completed, archived).',
+      inputSchema: {
+        type: 'object',
+        properties: {
+          id: { type: 'string', description: 'Task ID' },
+          status: { type: 'string', description: 'New status', enum: ['pending', 'in_progress', 'completed', 'archived'] }
+        },
+        required: ['id', 'status']
+      }
+    },
+    {
+      name: 'mcp__taskman_task_add_agent_note',
+      description: 'Add an agent note to a task (appended with [AgentX] prefix). Does not modify Connor original content.',
+      inputSchema: {
+        type: 'object',
+        properties: {
+          id: { type: 'string', description: 'Task ID' },
+          note: { type: 'string', description: 'Note to add' }
+        },
+        required: ['id', 'note']
+      }
+    },
+    {
+      name: 'mcp__taskman_task_delete',
+      description: 'Delete a task.',
+      inputSchema: {
+        type: 'object',
+        properties: { id: { type: 'string', description: 'Task ID' } },
+        required: ['id']
+      }
+    },
+    {
+      name: 'mcp__taskman_subtask_create',
+      description: 'Add a subtask to a task.',
+      inputSchema: {
+        type: 'object',
+        properties: {
+          task_id: { type: 'string', description: 'Parent task ID' },
+          title: { type: 'string', description: 'Subtask title' },
+          content: { type: 'string', description: 'Subtask content/details' }
+        },
+        required: ['task_id', 'title']
+      }
+    },
+    {
+      name: 'mcp__taskman_subtask_update_status',
+      description: 'Update subtask status.',
+      inputSchema: {
+        type: 'object',
+        properties: {
+          task_id: { type: 'string', description: 'Parent task ID' },
+          subtask_id: { type: 'string', description: 'Subtask ID' },
+          status: { type: 'string', description: 'New status', enum: ['pending', 'in_progress', 'completed'] }
+        },
+        required: ['task_id', 'subtask_id', 'status']
+      }
+    },
+    {
+      name: 'mcp__taskman_subtask_delete',
+      description: 'Delete a subtask.',
+      inputSchema: {
+        type: 'object',
+        properties: {
+          task_id: { type: 'string', description: 'Parent task ID' },
+          subtask_id: { type: 'string', description: 'Subtask ID' }
+        },
+        required: ['task_id', 'subtask_id']
+      }
+    },
+    {
+      name: 'mcp__taskman_idea_list',
+      description: 'List all ideas. Optionally filter by tag.',
+      inputSchema: {
+        type: 'object',
+        properties: { tag: { type: 'string', description: 'Filter by tag (optional)' } }
+      }
+    },
+    {
+      name: 'mcp__taskman_idea_get',
+      description: 'Get details of a specific idea by ID.',
+      inputSchema: {
+        type: 'object',
+        properties: { id: { type: 'string', description: 'Idea ID' } },
+        required: ['id']
+      }
+    },
+    {
+      name: 'mcp__taskman_idea_create',
+      description: 'Create a new idea.',
+      inputSchema: {
+        type: 'object',
+        properties: {
+          title: { type: 'string', description: 'Idea title' },
+          content: { type: 'string', description: 'Idea content' },
+          tags: { type: 'string', description: 'Comma-separated tags' }
+        },
+        required: ['title']
+      }
+    },
+    {
+      name: 'mcp__taskman_idea_add_agent_note',
+      description: 'Add an agent note to an idea (appended with [AgentX] prefix). Does not modify Connor original content.',
+      inputSchema: {
+        type: 'object',
+        properties: {
+          id: { type: 'string', description: 'Idea ID' },
+          note: { type: 'string', description: 'Note to add' }
+        },
+        required: ['id', 'note']
+      }
+    },
+    {
+      name: 'mcp__taskman_idea_delete',
+      description: 'Delete an idea.',
+      inputSchema: {
+        type: 'object',
+        properties: { id: { type: 'string', description: 'Idea ID' } },
+        required: ['id']
+      }
+    }
+  ]
+}));
+
+server.setRequestHandler(CallToolRequestSchema, async (request) => {
+  const { name, arguments: args } = request.params;
+  const store = loadStore();
+
+  switch (name) {
+    case 'mcp__taskman_task_list': {
+      let tasks = store.tasks || [];
+      if (args?.filter === 'pending') tasks = tasks.filter(t => t.status !== 'completed' && t.status !== 'archived');
+      else if (args?.filter === 'completed') tasks = tasks.filter(t => t.status === 'completed' || t.status === 'archived');
+
+      const lines = [`Found ${tasks.length} tasks:\n`];
+      for (const t of tasks) {
+        const status = getStatusIcon(t.status);
+        const due = t.due_date ? ` (due: ${t.due_date.split('T')[0]})` : '';
+        const progress = getProgress(t);
+        lines.push(`${status} [${t.id}] ${t.title}${due}${progress}`);
+      }
+      return { content: [{ type: 'text', text: lines.join('\n') }] };
+    }
+
+    case 'mcp__taskman_task_get': {
+      const task = (store.tasks || []).find(t => t.id === args.id);
+      if (!task) return { content: [{ type: 'text', text: `Task not found: ${args.id}` }], isError: true };
+
+      const due = task.due_date ? task.due_date.split('T')[0] : 'None';
+      const reminder = task.reminders?.length ? task.reminders[0].time : 'None';
+
+      let subtaskInfo = '';
+      if (task.subtasks && task.subtasks.length > 0) {
+        subtaskInfo = `\nSubtasks (${task.subtasks.length}):`;
+        for (const st of task.subtasks) {
+          subtaskInfo += `\n  ${getStatusIcon(st.status)} [${st.id}] ${st.title}`;
+        }
+      }
+
+      const text = `Task: ${task.title}\nID: ${task.id}\nStatus: ${task.status}\nDue: ${due}\nReminder: ${reminder}\nContent:\n${task.content || ''}${subtaskInfo}\nCreated: ${task.created_at}\nUpdated: ${task.updated_at}`;
+      return { content: [{ type: 'text', text }] };
+    }
+
+    case 'mcp__taskman_task_create': {
+      if (!args?.title) return { content: [{ type: 'text', text: 'Title is required' }], isError: true };
+
+      const now = new Date().toISOString();
+      const task = {
+        id: generateId(),
+        title: args.title,
+        content: args.content || '',
+        status: 'pending',
+        subtasks: [],
+        due_date: args.due_date || null,
+        reminders: args.reminder ? [{ time: args.reminder, notified: false }] : [],
+        created_at: now,
+        updated_at: now
+      };
+      store.tasks = store.tasks || [];
+      store.tasks.push(task);
+      saveStore(store);
+      return { content: [{ type: 'text', text: `Task created: ${args.title}` }] };
+    }
+
+    case 'mcp__taskman_task_toggle': {
+      const idx = (store.tasks || []).findIndex(t => t.id === args.id);
+      if (idx === -1) return { content: [{ type: 'text', text: `Task not found: ${args.id}` }], isError: true };
+
+      store.tasks[idx].status = store.tasks[idx].status === 'completed' ? 'pending' : 'completed';
+      store.tasks[idx].updated_at = new Date().toISOString();
+      saveStore(store);
+      return { content: [{ type: 'text', text: `Task '${store.tasks[idx].title}' marked as ${store.tasks[idx].status}` }] };
+    }
+
+    case 'mcp__taskman_task_update_status': {
+      const idx = (store.tasks || []).findIndex(t => t.id === args.id);
+      if (idx === -1) return { content: [{ type: 'text', text: `Task not found: ${args.id}` }], isError: true };
+
+      const validStatuses = ['pending', 'in_progress', 'completed', 'archived'];
+      if (!validStatuses.includes(args.status)) {
+        return { content: [{ type: 'text', text: `Invalid status: ${args.status}` }], isError: true };
+      }
+
+      store.tasks[idx].status = args.status;
+      store.tasks[idx].updated_at = new Date().toISOString();
+      saveStore(store);
+      return { content: [{ type: 'text', text: `Task '${store.tasks[idx].title}' status updated to ${args.status}` }] };
+    }
+
+    case 'mcp__taskman_task_add_agent_note': {
+      const idx = (store.tasks || []).findIndex(t => t.id === args.id);
+      if (idx === -1) return { content: [{ type: 'text', text: `Task not found: ${args.id}` }], isError: true };
+
+      const timestamp = new Date().toISOString().split('T')[0] + ' ' + new Date().toTimeString().slice(0, 5);
+      const agentNote = `\n\n[AgentX ${timestamp}]\n${args.note}`;
+      store.tasks[idx].content = (store.tasks[idx].content || '') + agentNote;
+      store.tasks[idx].updated_at = new Date().toISOString();
+      saveStore(store);
+      return { content: [{ type: 'text', text: `Agent note added to task '${store.tasks[idx].title}'` }] };
+    }
+
+    case 'mcp__taskman_task_delete': {
+      const idx = (store.tasks || []).findIndex(t => t.id === args.id);
+      if (idx === -1) return { content: [{ type: 'text', text: `Task not found: ${args.id}` }], isError: true };
+
+      const title = store.tasks[idx].title;
+      store.tasks.splice(idx, 1);
+      saveStore(store);
+      return { content: [{ type: 'text', text: `Task '${title}' deleted` }] };
+    }
+
+    case 'mcp__taskman_subtask_create': {
+      if (!args?.title) return { content: [{ type: 'text', text: 'Title is required' }], isError: true };
+
+      const taskIdx = (store.tasks || []).findIndex(t => t.id === args.task_id);
+      if (taskIdx === -1) return { content: [{ type: 'text', text: `Task not found: ${args.task_id}` }], isError: true };
+
+      const now = new Date().toISOString();
+      const subtask = {
+        id: generateId(),
+        title: args.title,
+        content: args.content || '',
+        status: 'pending',
+        order: (store.tasks[taskIdx].subtasks || []).length,
+        created_at: now,
+        updated_at: now
+      };
+
+      store.tasks[taskIdx].subtasks = store.tasks[taskIdx].subtasks || [];
+      store.tasks[taskIdx].subtasks.push(subtask);
+      store.tasks[taskIdx].updated_at = now;
+      saveStore(store);
+      return { content: [{ type: 'text', text: `Subtask '${args.title}' added to task '${store.tasks[taskIdx].title}'` }] };
+    }
+
+    case 'mcp__taskman_subtask_update_status': {
+      const taskIdx = (store.tasks || []).findIndex(t => t.id === args.task_id);
+      if (taskIdx === -1) return { content: [{ type: 'text', text: `Task not found: ${args.task_id}` }], isError: true };
+
+      const subtaskIdx = (store.tasks[taskIdx].subtasks || []).findIndex(s => s.id === args.subtask_id);
+      if (subtaskIdx === -1) return { content: [{ type: 'text', text: `Subtask not found: ${args.subtask_id}` }], isError: true };
+
+      const validStatuses = ['pending', 'in_progress', 'completed'];
+      if (!validStatuses.includes(args.status)) {
+        return { content: [{ type: 'text', text: `Invalid status: ${args.status}` }], isError: true };
+      }
+
+      store.tasks[taskIdx].subtasks[subtaskIdx].status = args.status;
+      store.tasks[taskIdx].subtasks[subtaskIdx].updated_at = new Date().toISOString();
+      store.tasks[taskIdx].updated_at = new Date().toISOString();
+      saveStore(store);
+      return { content: [{ type: 'text', text: `Subtask '${store.tasks[taskIdx].subtasks[subtaskIdx].title}' status updated to ${args.status}` }] };
+    }
+
+    case 'mcp__taskman_subtask_delete': {
+      const taskIdx = (store.tasks || []).findIndex(t => t.id === args.task_id);
+      if (taskIdx === -1) return { content: [{ type: 'text', text: `Task not found: ${args.task_id}` }], isError: true };
+
+      const subtaskIdx = (store.tasks[taskIdx].subtasks || []).findIndex(s => s.id === args.subtask_id);
+      if (subtaskIdx === -1) return { content: [{ type: 'text', text: `Subtask not found: ${args.subtask_id}` }], isError: true };
+
+      const title = store.tasks[taskIdx].subtasks[subtaskIdx].title;
+      store.tasks[taskIdx].subtasks.splice(subtaskIdx, 1);
+      store.tasks[taskIdx].updated_at = new Date().toISOString();
+      saveStore(store);
+      return { content: [{ type: 'text', text: `Subtask '${title}' deleted` }] };
+    }
+
+    case 'mcp__taskman_idea_list': {
+      let ideas = store.ideas || [];
+      if (args?.tag) {
+        ideas = ideas.filter(i => (i.tags || []).some(t => t.toLowerCase() === args.tag.toLowerCase()));
+      }
+
+      const lines = [`Found ${ideas.length} ideas:\n`];
+      for (const idea of ideas) {
+        const tags = idea.tags?.length ? ` [${idea.tags.join(', ')}]` : '';
+        lines.push(`☞ [${idea.id}] ${idea.title}${tags}`);
+      }
+      return { content: [{ type: 'text', text: lines.join('\n') }] };
+    }
+
+    case 'mcp__taskman_idea_get': {
+      const idea = (store.ideas || []).find(i => i.id === args.id);
+      if (!idea) return { content: [{ type: 'text', text: `Idea not found: ${args.id}` }], isError: true };
+
+      const tags = idea.tags?.length ? idea.tags.join(', ') : 'None';
+      const text = `Idea: ${idea.title}\nID: ${idea.id}\nTags: ${tags}\nContent:\n${idea.content || ''}\nCreated: ${idea.created_at}\nUpdated: ${idea.updated_at}`;
+      return { content: [{ type: 'text', text }] };
+    }
+
+    case 'mcp__taskman_idea_create': {
+      if (!args?.title) return { content: [{ type: 'text', text: 'Title is required' }], isError: true };
+
+      const now = new Date().toISOString();
+      const tags = args.tags ? args.tags.split(',').map(t => t.trim()).filter(t => t) : [];
+      const idea = {
+        id: generateId(),
+        title: args.title,
+        content: args.content || '',
+        tags,
+        status: 'pending',
+        subtasks: [],
+        created_at: now,
+        updated_at: now
+      };
+      store.ideas = store.ideas || [];
+      store.ideas.push(idea);
+      saveStore(store);
+      return { content: [{ type: 'text', text: `Idea created: ${args.title}` }] };
+    }
+
+    case 'mcp__taskman_idea_add_agent_note': {
+      const idx = (store.ideas || []).findIndex(i => i.id === args.id);
+      if (idx === -1) return { content: [{ type: 'text', text: `Idea not found: ${args.id}` }], isError: true };
+
+      const timestamp = new Date().toISOString().split('T')[0] + ' ' + new Date().toTimeString().slice(0, 5);
+      const agentNote = `\n\n[AgentX ${timestamp}]\n${args.note}`;
+      store.ideas[idx].content = (store.ideas[idx].content || '') + agentNote;
+      store.ideas[idx].updated_at = new Date().toISOString();
+      saveStore(store);
+      return { content: [{ type: 'text', text: `Agent note added to idea '${store.ideas[idx].title}'` }] };
+    }
+
+    case 'mcp__taskman_idea_delete': {
+      const idx = (store.ideas || []).findIndex(i => i.id === args.id);
+      if (idx === -1) return { content: [{ type: 'text', text: `Idea not found: ${args.id}` }], isError: true };
+
+      const title = store.ideas[idx].title;
+      store.ideas.splice(idx, 1);
+      saveStore(store);
+      return { content: [{ type: 'text', text: `Idea '${title}' deleted` }] };
+    }
+
+    default:
+      return { content: [{ type: 'text', text: `Unknown tool: ${name}` }], isError: true };
+  }
+});
+
+const transport = new StdioServerTransport();
+await server.connect(transport);

package/package.json

@@ -0,0 +1,16 @@
+{
+  "name": "taskman-mcp",
+  "version": "0.1.1",
+  "description": "MCP server for taskman task and idea management",
+  "type": "module",
+  "main": "app.js",
+  "bin": {
+    "taskman-mcp": "./app.js"
+  },
+  "scripts": {
+    "start": "node app.js"
+  },
+  "dependencies": {
+    "@modelcontextprotocol/sdk": "^0.5.0"
+  }
+}