todoai-mcp 0.1.0

package/.env.example

@@ -0,0 +1,13 @@
+# TodoAI MCP Server Configuration
+# Copy this to .env and fill in your values.
+
+# Required: API key generated from TodoAI Settings -> API Keys
+TODOAI_API_KEY=tai_xxxxx
+
+# Backend API URL (default: http://localhost:3000)
+# Change to your deployed backend URL for remote/cloud usage
+# TODOAI_API_URL=https://your-backend.vercel.app
+
+# Set PORT for HTTP mode (Streamable HTTP transport)
+# Leave unset for stdio mode (local AI agents)
+# PORT=3001

package/README.md

@@ -0,0 +1,299 @@
+# TodoAI MCP Server
+
+Let any AI agent manage your todos through the Model Context Protocol — works with **every** MCP-compatible client.
+
+---
+
+## Install
+
+```bash
+# Run without installing (auto-cached by npm):
+npx todoai-mcp
+
+# Or install globally:
+npm install -g todoai-mcp
+todoai-mcp
+
+# Or install locally:
+npm install todoai-mcp
+npx todoai-mcp
+```
+
+---
+
+## Quick Start
+
+### One-command setup (interactive)
+
+```bash
+npx todoai-mcp --init
+```
+
+This will ask for your API key, backend URL, and port — then write `.env` and print config snippets for every tool.
+
+### Manual setup
+
+```bash
+npx todoai-mcp
+# If API key is missing, it shows instructions and exits
+
+# Or with env vars inline:
+TODOAI_API_KEY=tai_xxxxx npx todoai-mcp
+```
+
+That's it. Stdio transport is ready. Connect from any MCP client below.
+
+---
+
+## Configuration
+
+### 1. Generate an API Key
+
+In the TodoAI app → **Settings → API Keys** → create a key (e.g. "MCP Server").
+
+### 2. Start the server
+
+```bash
+# Interactive setup (recommended):
+npx todoai-mcp --init
+
+# Or start directly with env vars:
+TODOAI_API_KEY=tai_xxxxx npx todoai-mcp
+
+# Or locally after checkout:
+cp .env.example .env
+nano .env
+node src/index.js
+
+# HTTP mode (for remote/cloud IDE agents):
+PORT=3001 TODOAI_API_KEY=tai_xxxxx npx todoai-mcp
+```
+
+---
+
+## Connecting Every MCP-Compatible Tool
+
+### Claude Desktop (Anthropic)
+
+Edit `claude_desktop_config.json` (File → Settings → Developer → Edit Config):
+
+```json
+{
+  "mcpServers": {
+    "todoai": {
+      "command": "npx",
+      "args": ["-y", "todoai-mcp"],
+      "env": {
+        "TODOAI_API_KEY": "tai_xxxxx",
+        "TODOAI_API_URL": "http://localhost:3000"
+      }
+    }
+  }
+}
+```
+
+> `-y` auto-downloads the package if not cached. No install needed.
+
+### Claude Code CLI (Anthropic)
+
+```bash
+# One-shot with npx:
+TODOAI_API_KEY=tai_xxxxx claude --mcp "todoai=npx -y todoai-mcp"
+```
+
+In `.claude/settings.json` or `~/.claude/settings.json`:
+
+```json
+{
+  "mcpServers": {
+    "todoai": {
+      "command": "npx",
+      "args": ["-y", "todoai-mcp"],
+      "env": {
+        "TODOAI_API_KEY": "tai_xxxxx"
+      }
+    }
+  }
+}
+```
+
+### Cursor
+
+Settings → Features → MCP Servers → Add Server:
+
+| Field | Value |
+|---|---|
+| Name | `todoai` |
+| Type | `command` |
+| Command | `npx -y todoai-mcp` |
+
+Then add `TODOAI_API_KEY=tai_xxxxx` in the server's environment variables.
+
+### Windsurf
+
+In `.windsurf/config.json` at the project root:
+
+```json
+{
+  "mcpServers": {
+    "todoai": {
+      "command": "npx",
+      "args": ["-y", "todoai-mcp"],
+      "env": {
+        "TODOAI_API_KEY": "tai_xxxxx"
+      }
+    }
+  }
+}
+```
+
+### GitHub Copilot (VS Code)
+
+Via VS Code `settings.json`:
+
+```json
+{
+  "github.copilot.mcpServers": {
+    "todoai": {
+      "command": "npx",
+      "args": ["-y", "todoai-mcp"],
+      "env": {
+        "TODOAI_API_KEY": "tai_xxxxx"
+      }
+    }
+  }
+}
+```
+
+### Any MCP-compatible CLI (`mcp-cli`, `mcp-gateway`, etc.)
+
+```bash
+# Via npx (auto-download):
+TODOAI_API_KEY=tai_xxxxx npx todoai-mcp
+
+# Via the binary (if installed globally):
+npm install -g todoai-mcp
+todoai-mcp --init
+```
+
+### Pipe / script usage (any shell)
+
+```bash
+echo '{"jsonrpc":"2.0","id":1,"method":"tools/list"}' | \
+  TODOAI_API_KEY=tai_xxxxx npx todoai-mcp
+```
+
+### Generic MCP Host (any MCP-compatible tool)
+
+The server complies with the MCP stdio protocol. Any tool that supports `command`-type MCP servers works with:
+
+- **command**: `npx`
+- **args**: `["-y", "todoai-mcp"]`
+- **env**: `{ "TODOAI_API_KEY": "tai_xxxxx" }`
+
+### Remote HTTP Mode (for cloud IDEs / agents that only speak HTTP)
+
+```bash
+PORT=3001 TODOAI_API_KEY=tai_xxxxx npx todoai-mcp
+```
+
+Connect from any HTTP MCP client:
+
+```json
+{
+  "mcpServers": {
+    "todoai": {
+      "url": "http://localhost:3001/mcp",
+      "headers": {
+        "x-api-key": "tai_xxxxx"
+      }
+    }
+  }
+}
+```
+
+---
+
+## Security
+
+| Layer | Protection |
+|---|---|
+| **API Key** | All requests require the `x-api-key` header matching `TODOAI_API_KEY`. Reject with `401` if invalid. |
+| **Rate Limit** | 100 requests/hour per IP (HTTP mode). Resets every hour. |
+| **Backend Auth** | The MCP server authenticates with the backend using your API key. All operations run under that user's permissions and plan limits. |
+
+### Security Best Practices
+
+- Keep `TODOAI_API_KEY` in environment variables, never in code
+- Do not commit `.env` to version control (`.env` is in `.gitignore`)
+- For remote deployments, use a secrets manager instead of plain env vars
+- Each MCP server instance uses one API key — generate a dedicated key per instance
+
+---
+
+## Plan Limits (Free / Pro / Business)
+
+The backend enforces these limits on every API call made through the MCP server:
+
+| Tier | Rate Limit | Max Active Tasks | Features |
+|---|---|---|---|
+| **Free** | 100 req/hour | 50 | Basic CRUD, AI parse, daily summary |
+| **Pro** ($) | 1000 req/hour | Unlimited | Priority suggestions, breakdown, reschedule |
+| **Business** ($$) | 5000 req/hour | Unlimited | All features, team workspaces, audit logs |
+
+When a limit is hit, the MCP tool returns a clear error message telling you which limit was exceeded and what to do.
+
+---
+
+## Deployment
+
+### Vercel (serverless)
+
+Push `todo-mcp/` to a GitHub repo → Import to Vercel:
+
+- **Root Directory**: `todo-mcp`
+- **Build Command**: `npm install`
+- **Start Command**: `node src/index.js`
+- **Environment Variables**: `TODOAI_API_KEY`, `TODOAI_API_URL`, `PORT=3001`
+- Endpoint: `https://your-app.vercel.app/mcp`
+
+### Railway / Render / Fly.io (long-running)
+
+```bash
+# Set env vars: PORT=3001, TODOAI_API_KEY, TODOAI_API_URL
+# Start command: node src/index.js
+# Or if published: npx todoai-mcp
+```
+
+Health check: `https://your-app.com/health`
+
+---
+
+## Available Tools
+
+| Tool | Description |
+|---|---|
+| `list_todos` | List, search, and filter todos |
+| `create_todo` | Create a todo (supports natural language + workspace) |
+| `complete_todo` | Mark a todo as complete |
+| `delete_todo` | Delete a todo |
+| `suggest_priority` | AI priority analysis |
+| `summarize_day` | Daily task summary |
+| `break_down_task` | Split a task into subtasks |
+| `reschedule` | View schedule overview |
+
+## Examples
+
+- "What's on my todo list?"
+- "Add 'Buy groceries tomorrow' high priority"
+- "Complete the task about reviewing the PR"
+- "Summarize my day"
+- "Create a task in the Design workspace"
+
+## Environment Variables
+
+| Variable | Required | Default | Description |
+|---|---|---|---|
+| `TODOAI_API_KEY` | Yes | — | API key from TodoAI Settings → API Keys |
+| `TODOAI_API_URL` | No | `http://localhost:3000` | Backend API URL |
+| `PORT` | No | — | Set for HTTP mode; omit for stdio |

package/api/index.js

@@ -0,0 +1,6 @@
+import 'dotenv/config';
+import { createApp } from '../src/app.js';
+
+const app = createApp();
+
+export default app;

package/package.json

@@ -0,0 +1,54 @@
+{
+  "name": "todoai-mcp",
+  "version": "0.1.0",
+  "description": "TodoAI MCP Server — let any AI agent manage your todos natively through the Model Context Protocol",
+  "type": "module",
+  "main": "src/index.js",
+  "bin": {
+    "todoai-mcp": "./src/index.js"
+  },
+  "files": [
+    "src/",
+    "api/",
+    ".env.example",
+    "README.md"
+  ],
+  "scripts": {
+    "start": "node src/index.js",
+    "dev": "node --watch src/index.js",
+    "init": "node src/index.js --init",
+    "setup": "node src/index.js --init",
+    "prepublishOnly": "echo 'Publishing to npm...'",
+    "postinstall": "echo 'TodoAI MCP Server installed. Run: npx todoai-mcp --init to configure'"
+  },
+  "keywords": [
+    "mcp",
+    "model-context-protocol",
+    "todo",
+    "task-management",
+    "ai",
+    "claude",
+    "cursor",
+    "windsurf",
+    "copilot"
+  ],
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/Ashish-chanchal/todo-mcp.git"
+  },
+  "homepage": "https://github.com/Ashish-chanchal/todo-mcp#readme",
+  "bugs": {
+    "url": "https://github.com/Ashish-chanchal/todo-mcp/issues"
+  },
+  "engines": {
+    "node": ">=18"
+  },
+  "dependencies": {
+    "@modelcontextprotocol/sdk": "^1.29.0",
+    "cors": "^2.8.6",
+    "dotenv": "^16.4.5",
+    "express": "^5.2.1",
+    "zod": "^3.23.8"
+  }
+}

package/src/app.js

@@ -0,0 +1,65 @@
+import express from 'express';
+import cors from 'cors';
+import { randomUUID } from 'node:crypto';
+import { StreamableHTTPServerTransport } from '@modelcontextprotocol/sdk/server/streamableHttp.js';
+import { server, API_KEY } from './server.js';
+
+const requestCounts = new Map();
+setInterval(() => requestCounts.clear(), 60 * 60 * 1000);
+
+function rateLimiter(req, res, next) {
+  const key = req.ip || 'unknown';
+  const current = requestCounts.get(key) || { count: 0, firstRequest: Date.now() };
+
+  if (current.count >= 100) {
+    const resetTime = new Date(current.firstRequest + 60 * 60 * 1000);
+    return res.status(429).json({
+      msg: `Too many requests. Rate limit resets at ${resetTime.toLocaleTimeString()}.`,
+      resetAt: resetTime,
+    });
+  }
+
+  current.count += 1;
+  requestCounts.set(key, current);
+  next();
+}
+
+function requireApiKey(req, res, next) {
+  if (!API_KEY) return next();
+  const key = req.headers['x-api-key'] || req.headers['api-key'];
+  if (!key || key !== API_KEY) {
+    return res.status(401).json({ msg: 'Invalid or missing x-api-key header. Must match TODOAI_API_KEY.' });
+  }
+  next();
+}
+
+let transport = null;
+
+export function createApp() {
+  const app = express();
+  app.use(cors());
+  app.use(express.json());
+  app.use(rateLimiter);
+
+  app.all('/mcp', requireApiKey, (req, res) => {
+    if (!transport) {
+      transport = new StreamableHTTPServerTransport({
+        sessionIdGenerator: () => randomUUID(),
+      });
+      server.connect(transport);
+    }
+    transport.handleRequest(req, res, req.body);
+  });
+
+  app.get('/health', (_req, res) => {
+    res.json({
+      status: 'ok',
+      server: 'todoai-mcp',
+      version: '0.1.0',
+      apiKeyConfigured: !!API_KEY,
+      sessionId: transport?.sessionId || null,
+    });
+  });
+
+  return app;
+}

package/src/client.js

@@ -0,0 +1,106 @@
+const TODOAI_API_URL = process.env.TODOAI_API_URL || 'http://127.0.0.1:3000';
+
+const BASE_HEADERS = {
+  'Content-Type': 'application/json',
+};
+
+export class TodoAiClient {
+  constructor(apiKey) {
+    this.apiKey = apiKey;
+  }
+
+  headers(extra = {}) {
+    return {
+      ...BASE_HEADERS,
+      'x-api-key': this.apiKey,
+      ...extra,
+    };
+  }
+
+  async request(method, path, body) {
+    const url = `${TODOAI_API_URL}${path}`;
+    const options = {
+      method,
+      headers: this.headers(),
+    };
+    if (body) options.body = JSON.stringify(body);
+
+    const res = await fetch(url, options);
+    const data = await res.json();
+
+    if (!res.ok) {
+      throw new Error(data.msg || `API error: ${res.status}`);
+    }
+    return data;
+  }
+
+  get(path) {
+    return this.request('GET', path);
+  }
+
+  post(path, body) {
+    return this.request('POST', path, body);
+  }
+
+  put(path, body) {
+    return this.request('PUT', path, body);
+  }
+
+  del(path, body) {
+    return this.request('DELETE', path, body);
+  }
+
+  // --- Tool-specific API calls ---
+
+  async listTodos(params = {}) {
+    const query = {};
+    if (params.filter === 'active') query.completed = 'false';
+    else if (params.filter === 'completed') query.completed = 'true';
+    if (params.priority) query.priority = params.priority;
+    if (params.tag) query.tag = params.tag;
+    if (params.q) query.q = params.q;
+    if (params.page) query.page = params.page;
+    if (params.limit) query.limit = params.limit;
+    if (params.teamId) query.teamId = params.teamId;
+    const qs = new URLSearchParams(query).toString();
+    return this.get(`/todos${qs ? `?${qs}` : ''}`);
+  }
+
+  async createTodo(title, description, priority, dueDate, tags, teamId) {
+    const body = { title, description, priority, dueDate, tags };
+    if (teamId) body.teamId = teamId;
+    return this.post('/todo', body);
+  }
+
+  async completeTodo(id) {
+    return this.put('/completed', { id });
+  }
+
+  async deleteTodo(id) {
+    return this.del('/delete', { id });
+  }
+
+  async searchTodos(query) {
+    return this.get(`/todos?q=${encodeURIComponent(query)}`);
+  }
+
+  async aiParse(text) {
+    let body;
+    if (typeof text === 'string') {
+      body = { text };
+    } else if (typeof text === 'object' && text !== null) {
+      body = text;
+    } else {
+      body = { text: String(text) };
+    }
+    return this.post('/ai/parse', body);
+  }
+
+  async aiAnalyze(text) {
+    return this.post('/ai/analyze', { text });
+  }
+
+  async aiPrioritize() {
+    return this.post('/ai/prioritize');
+  }
+}

package/src/index.js

@@ -0,0 +1,139 @@
+#!/usr/bin/env node
+
+import 'dotenv/config';
+import { createInterface } from 'node:readline';
+import { existsSync, writeFileSync } from 'node:fs';
+import { join, dirname } from 'node:path';
+import { fileURLToPath } from 'node:url';
+import { API_KEY, server } from './server.js';
+import { createApp } from './app.js';
+
+const __dirname = dirname(fileURLToPath(import.meta.url));
+
+function ask(query) {
+  const rl = createInterface({ input: process.stdin, output: process.stdout });
+  return new Promise(resolve => rl.question(query, answer => { rl.close(); resolve(answer.trim()); }));
+}
+
+function printConfig(key, backendUrl, port) {
+  const todoaiBackend = backendUrl || 'http://localhost:3000';
+  const isHttp = !!port;
+  const transport = isHttp ? 'http' : 'stdio';
+  const serverRef = isHttp ? `http://localhost:${port}/mcp` : 'node /path/to/todo-mcp/src/index.js';
+
+  console.error('');
+  console.error('═'.repeat(50));
+  console.error(' TodoAI MCP Server — Configuration');
+  console.error('═'.repeat(50));
+  console.error(` Transport : ${transport}`);
+  console.error(` Backend   : ${todoaiBackend}`);
+  console.error(` API Key   : ${key ? key.substring(0, 8) + '...' : 'NOT SET'}`);
+  console.error('');
+
+  const configs = {
+    'Claude Desktop (claude_desktop_config.json)': {
+      mcpServers: {
+        todoai: isHttp
+          ? { url: `http://localhost:${port}/mcp`, headers: { 'x-api-key': key } }
+          : { command: 'node', args: ['/path/to/todo-mcp/src/index.js'], env: { TODOAI_API_KEY: key, TODOAI_API_URL: todoaiBackend } }
+      }
+    },
+    'Claude Code (.claude/settings.json)': isHttp
+      ? { mcpServers: { todoai: { url: `http://localhost:${port}/mcp`, headers: { 'x-api-key': key } } } }
+      : { mcpServers: { todoai: { command: 'node', args: ['/path/to/todo-mcp/src/index.js'], env: { TODOAI_API_KEY: key } } } },
+    'MCP CLI': isHttp
+      ? `npx @anthropic-ai/mcp-cli connect --url http://localhost:${port}/mcp --headers '{"x-api-key":"${key}"}'`
+      : `TODOAI_API_KEY=${key} npx @anthropic-ai/mcp-cli --server "node /path/to/todo-mcp/src/index.js"`,
+    'Any MCP tool (stdio)': `TODOAI_API_KEY=${key} node /path/to/todo-mcp/src/index.js`,
+  };
+
+  for (const [label, cfg] of Object.entries(configs)) {
+    console.error(`── ${label}`);
+    console.error(JSON.stringify(cfg, null, 2));
+    console.error('');
+  }
+  console.error('═'.repeat(50));
+  console.error('');
+}
+
+async function runSetup() {
+  console.error('');
+  console.error(' TodoAI MCP Server — Setup');
+  console.error('═'.repeat(50));
+
+  let key = API_KEY || process.env.TODOAI_API_KEY;
+  if (!key) {
+    console.error(' No TODOAI_API_KEY found. Generate one in TodoAI → Settings → API Keys.');
+    key = await ask(' Enter your API key (tai_...): ');
+    if (!key) {
+      console.error(' API key is required. Exiting.');
+      process.exit(1);
+    }
+  }
+
+  const backendUrl = process.env.TODOAI_API_URL || (await ask(` Backend URL [http://localhost:3000]: `)) || 'http://localhost:3000';
+  const port = process.env.PORT || (await ask(` HTTP port (empty for stdio): `));
+
+  // Write .env
+  const envPath = join(process.cwd(), '.env');
+  const envContent = [
+    `TODOAI_API_KEY=${key}`,
+    `TODOAI_API_URL=${backendUrl}`,
+    port ? `PORT=${port}` : '',
+  ].filter(Boolean).join('\n') + '\n';
+
+  writeFileSync(envPath, envContent);
+  console.error(`\n .env written to ${envPath}`);
+
+  printConfig(key, backendUrl, port);
+  console.error(' Run: node src/index.js (or just: npx todoai-mcp)');
+  console.error('');
+}
+
+async function main() {
+  const args = process.argv.slice(2);
+
+  if (args.includes('--init') || args.includes('setup')) {
+    await runSetup();
+    process.exit(0);
+  }
+
+  if (!API_KEY) {
+    console.error('');
+    console.error(' ╔══════════════════════════════════════════════════╗');
+    console.error(' ║  TODOAI_API_KEY is not set.                    ║');
+    console.error(' ║                                                ║');
+    console.error(' ║  1. Generate a key in TodoAI → Settings →      ║');
+    console.error(' ║     API Keys                                    ║');
+    console.error(' ║  2. Set it in your environment or .env file    ║');
+    console.error(' ║     export TODOAI_API_KEY=tai_xxxxx            ║');
+    console.error(' ║                                                ║');
+    console.error(' ║  Run with --init for interactive setup:        ║');
+    console.error(' ║     npx todoai-mcp --init                      ║');
+    console.error(' ╚══════════════════════════════════════════════════╝');
+    console.error('');
+    process.exit(1);
+  }
+
+  const PORT = process.env.PORT;
+
+  if (PORT) {
+    const app = createApp();
+    app.listen(PORT, () => {
+      console.error(`TodoAI MCP Server running on http://localhost:${PORT}/mcp`);
+      printConfig(API_KEY, process.env.TODOAI_API_URL, PORT);
+    });
+  } else {
+    const { StdioServerTransport } = await import('@modelcontextprotocol/sdk/server/stdio.js');
+    const transport = new StdioServerTransport();
+    await server.connect(transport);
+    console.error('TodoAI MCP Server running on stdio');
+    console.error('');
+    printConfig(API_KEY, process.env.TODOAI_API_URL);
+  }
+}
+
+main().catch((err) => {
+  console.error('Fatal error:', err);
+  process.exit(1);
+});

package/src/server.js

@@ -0,0 +1,470 @@
+import { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
+import { z } from 'zod';
+import { TodoAiClient } from './client.js';
+
+export const API_KEY = process.env.TODOAI_API_KEY || process.env.TODOAI_DEV_KEY;
+export const client = API_KEY ? new TodoAiClient(API_KEY) : null;
+export const server = new McpServer({ name: 'todoai', version: '0.1.0' });
+
+export function requireClient() {
+  if (!client) {
+    return {
+      content: [{ type: 'text', text: 'TODOAI_API_KEY not configured. Generate an API key in Settings → API Keys and set the TODOAI_API_KEY environment variable.' }],
+    };
+  }
+  return null;
+}
+
+const PRIORITY_ORDER = { high: 0, medium: 1, low: 2 };
+
+function today() {
+  const d = new Date();
+  d.setHours(0, 0, 0, 0);
+  return d;
+}
+
+function daysFromNow(n) {
+  const d = today();
+  d.setDate(d.getDate() + n);
+  return d;
+}
+
+function isSameDay(a, b) {
+  return a.getFullYear() === b.getFullYear()
+    && a.getMonth() === b.getMonth()
+    && a.getDate() === b.getDate();
+}
+
+function generatePriorityReasoning(text, priority) {
+  const lower = text.toLowerCase();
+  const urgentWords = ['urgent', 'asap', 'immediately', 'critical', 'deadline', 'emergency', 'important', 'must'];
+  const mediumWords = ['soon', 'week', 'next', 'pending', 'upcoming', 'shortly'];
+
+  if (priority === 'high') {
+    const found = urgentWords.filter(w => lower.includes(w));
+    if (found.length > 0) return `Contains urgency signals: ${found.join(', ')}`;
+    return 'Task appears time-sensitive or critical based on analysis';
+  }
+  if (priority === 'medium') {
+    const found = mediumWords.filter(w => lower.includes(w));
+    if (found.length > 0) return `Contains moderate-timeline signals: ${found.join(', ')}`;
+    return 'Task has moderate importance but no immediate urgency';
+  }
+  return 'Task appears low-urgency or informational, no critical time pressure detected';
+}
+
+function breakDownTask(text) {
+  const transitionWords = ['first', 'then', 'next', 'finally', 'after', 'before', 'lastly', 'second', 'third', 'fourth'];
+  const lower = text.toLowerCase();
+
+  const foundTransitions = transitionWords.filter(t => lower.includes(t));
+  const hasStructure = foundTransitions.length >= 2;
+
+  if (hasStructure) {
+    const steps = [];
+    const parts = text.split(new RegExp(`\\b(${foundTransitions.join('|')})\\b`, 'gi')).filter(p => p.trim());
+    let stepNum = 1;
+    for (const part of parts) {
+      if (transitionWords.includes(part.toLowerCase())) continue;
+      const trimmed = part.trim().replace(/^[,\s]+|[,\s]+$/g, '');
+      if (trimmed && !steps.includes(trimmed)) {
+        steps.push(trimmed);
+      }
+    }
+    return steps.slice(0, 5);
+  }
+
+  const keywords = {
+    write: ['Outline key points', 'Draft the content', 'Review and revise', 'Format the final version'],
+    create: ['Research requirements', 'Draft initial version', 'Review and refine', 'Finalize deliverable'],
+    develop: ['Gather specifications', 'Set up environment', 'Implement core logic', 'Test and debug', 'Deploy'],
+    build: ['Plan the structure', 'Gather materials', 'Assemble components', 'Test and iterate', 'Complete'],
+    organize: ['List all items', 'Categorize by type', 'Sort and prioritize', 'Create storage system'],
+    plan: ['Define objectives', 'Identify resources', 'Create timeline', 'Assign responsibilities', 'Review plan'],
+    learn: ['Find learning resources', 'Set study schedule', 'Practice regularly', 'Test knowledge', 'Review gaps'],
+    fix: ['Reproduce the issue', 'Identify root cause', 'Implement fix', 'Test the solution', 'Verify in production'],
+    clean: ['Declutter the area', 'Sort items', 'Deep clean surfaces', 'Organize remaining items', 'Maintain regularly'],
+  };
+
+  for (const [keyword, steps] of Object.entries(keywords)) {
+    if (lower.includes(keyword)) {
+      return steps;
+    }
+  }
+
+  return [
+    'Research and gather information',
+    'Plan the approach',
+    'Execute the main work',
+    'Review and refine results',
+    'Complete and follow up',
+  ];
+}
+
+// ── Tool 1: list_todos ──
+server.registerTool(
+  'list_todos',
+  {
+    inputSchema: {
+      filter: z.string().optional().describe('Filter: "all", "active", "completed"'),
+      priority: z.string().optional().describe('Filter by priority: "low", "medium", "high"'),
+      tag: z.string().optional().describe('Filter by tag name'),
+      q: z.string().optional().describe('Search query'),
+      page: z.number().optional().describe('Page number (1-based)'),
+      limit: z.number().optional().describe('Items per page (default 20)'),
+      teamId: z.string().optional().describe('Workspace/team ID (omit for personal workspace)'),
+    },
+  },
+  async (args) => {
+    const noClient = requireClient(); if (noClient) return noClient;
+    try {
+      const data = await client.listTodos(args);
+      const todos = data.todos || [];
+      if (todos.length === 0) {
+        return { content: [{ type: 'text', text: 'No todos found.' }] };
+      }
+      const lines = todos.map((t, i) => {
+        const status = t.completed ? '✅' : '⬜';
+        const due = t.dueDate ? ` (due: ${new Date(t.dueDate).toLocaleDateString()})` : '';
+        const priority = t.priority ? ` [${t.priority}]` : '';
+        const tags = t.tags?.length ? ` #${t.tags.join(', #')}` : '';
+        return `${i + 1}. ${status} ${t.title}${priority}${due}${tags}`;
+      });
+      return { content: [{ type: 'text', text: lines.join('\n') }] };
+    } catch (err) {
+      return { content: [{ type: 'text', text: `Error: ${err.message}` }], isError: true };
+    }
+  }
+);
+
+// ── Tool 2: create_todo ──
+server.registerTool(
+  'create_todo',
+  {
+    inputSchema: {
+      title: z.string().describe('Todo title or natural language description'),
+      description: z.string().optional().describe('Detailed description'),
+      priority: z.enum(['low', 'medium', 'high']).optional().describe('Priority level'),
+      dueDate: z.string().optional().describe('Due date (YYYY-MM-DD or natural language)'),
+      tags: z.array(z.string()).optional().describe('Tags (max 3)'),
+      teamId: z.string().optional().describe('Workspace/team ID to create the todo in (omit for personal workspace)'),
+    },
+  },
+  async (args) => {
+    const noClient = requireClient(); if (noClient) return noClient;
+    try {
+      let { title, description, priority, dueDate, tags, teamId } = args;
+
+      if (tags) {
+        const seen = new Set();
+        tags = tags.map(t => String(t).toLowerCase().trim()).filter(t => t && !seen.has(t) && seen.add(t)).slice(0, 3);
+      }
+
+      if (title.split(' ').length > 4 || dueDate || priority) {
+        const aiResult = await client.aiParse({ text: title, teamId });
+        if (aiResult.todo) {
+          return {
+            content: [{
+              type: 'text',
+              text: `Created todo: "${aiResult.todo.title}"\nPriority: ${aiResult.todo.priority}\nDue: ${aiResult.todo.dueDate || 'No due date'}\nTags: ${(aiResult.todo.tags || []).join(', ') || 'None'}`,
+            }],
+          };
+        }
+      }
+
+      const data = await client.createTodo(title, description || '', priority || 'medium', dueDate || null, tags || [], teamId);
+      return {
+        content: [{
+          type: 'text',
+          text: `Created todo: "${data.todo.title}" (${data.todo._id})`,
+        }],
+      };
+    } catch (err) {
+      return { content: [{ type: 'text', text: `Error: ${err.message}` }], isError: true };
+    }
+  }
+);
+
+// ── Tool 3: complete_todo ──
+server.registerTool(
+  'complete_todo',
+  {
+    inputSchema: {
+      id: z.string().optional().describe('Todo ID to mark as complete'),
+      search: z.string().optional().describe('Search text to find and complete a todo'),
+    },
+  },
+  async (args) => {
+    const noClient = requireClient(); if (noClient) return noClient;
+    try {
+      let todoId = args.id;
+
+      if (!todoId && args.search) {
+        const data = await client.searchTodos(args.search);
+        const todos = data.todos || [];
+        if (todos.length === 0) {
+          return { content: [{ type: 'text', text: `No todos matching "${args.search}"` }] };
+        }
+        todoId = todos[0]._id;
+      }
+
+      if (!todoId) {
+        return { content: [{ type: 'text', text: 'Provide an id or search text' }] };
+      }
+
+      await client.completeTodo(todoId);
+      return { content: [{ type: 'text', text: `Todo ${todoId} marked as complete.` }] };
+    } catch (err) {
+      return { content: [{ type: 'text', text: `Error: ${err.message}` }], isError: true };
+    }
+  }
+);
+
+// ── Tool 4: delete_todo ──
+server.registerTool(
+  'delete_todo',
+  {
+    inputSchema: {
+      id: z.string().optional().describe('Todo ID to delete'),
+      search: z.string().optional().describe('Search text to find and delete a todo'),
+    },
+  },
+  async (args) => {
+    const noClient = requireClient(); if (noClient) return noClient;
+    try {
+      let todoId = args.id;
+
+      if (!todoId && args.search) {
+        const data = await client.searchTodos(args.search);
+        const todos = data.todos || [];
+        if (todos.length === 0) {
+          return { content: [{ type: 'text', text: `No todos matching "${args.search}"` }] };
+        }
+        todoId = todos[0]._id;
+      }
+
+      if (!todoId) {
+        return { content: [{ type: 'text', text: 'Provide an id or search text' }] };
+      }
+
+      await client.deleteTodo(todoId);
+      return { content: [{ type: 'text', text: `Todo ${todoId} deleted.` }] };
+    } catch (err) {
+      return { content: [{ type: 'text', text: `Error: ${err.message}` }], isError: true };
+    }
+  }
+);
+
+// ── Tool 5: suggest_priority ──
+server.registerTool(
+  'suggest_priority',
+  {
+    inputSchema: {
+      text: z.string().describe('Task description to analyze'),
+    },
+  },
+  async (args) => {
+    const noClient = requireClient(); if (noClient) return noClient;
+    try {
+      const data = await client.aiAnalyze(args.text);
+      const priority = data.parsed?.priority || 'medium';
+      const reasoning = generatePriorityReasoning(args.text, priority);
+
+      return {
+        content: [{
+          type: 'text',
+          text: `Based on analysis: Priority — ${priority}. Reasoning: ${reasoning}`,
+        }],
+      };
+    } catch (err) {
+      return { content: [{ type: 'text', text: `Error: ${err.message}` }], isError: true };
+    }
+  }
+);
+
+// ── Tool 6: summarize_day ──
+server.registerTool(
+  'summarize_day',
+  {
+    inputSchema: {
+      date: z.string().optional().describe('Date to summarize (YYYY-MM-DD, defaults to today)'),
+      teamId: z.string().optional().describe('Workspace/team ID (omit for personal workspace)'),
+    },
+  },
+  async (args) => {
+    const noClient = requireClient(); if (noClient) return noClient;
+    try {
+      const data = await client.listTodos({ teamId: args.teamId });
+      const todos = data.todos || [];
+      const now = today();
+      const active = todos.filter(t => !t.completed);
+      const completed = todos.filter(t => t.completed);
+      const highPriority = active.filter(t => t.priority === 'high');
+      const overdue = active.filter(t => t.dueDate && new Date(t.dueDate) < now);
+      const dueToday = active.filter(t => t.dueDate && isSameDay(new Date(t.dueDate), now));
+      const total = todos.length;
+      const activeCount = active.length;
+      const completedCount = completed.length;
+
+      const lines = [];
+      lines.push('# 📋 TodoAI Daily Summary');
+      lines.push('');
+      lines.push('## 📊 Overview');
+      lines.push(`| Metric | Count |`);
+      lines.push(`|--------|-------|`);
+      lines.push(`| **Total Tasks** | ${total} |`);
+      lines.push(`| **Active** | ${activeCount} |`);
+      lines.push(`| **Completed** | ${completedCount} |`);
+      lines.push(`| **Overdue** | ${overdue.length} |`);
+      lines.push(`| **High Priority** | ${highPriority.length} |`);
+      lines.push(`| **Due Today** | ${dueToday.length} |`);
+      lines.push('');
+
+      if (overdue.length > 0) {
+        lines.push('## ⚠️ Overdue');
+        overdue.forEach(t => {
+          const due = new Date(t.dueDate).toLocaleDateString();
+          lines.push(`- **${t.title}** — due ${due} [${t.priority || 'medium'}]`);
+        });
+        lines.push('');
+      }
+
+      if (highPriority.length > 0) {
+        lines.push('## 🔴 High Priority');
+        highPriority.forEach(t => {
+          const due = t.dueDate ? ` (due ${new Date(t.dueDate).toLocaleDateString()})` : '';
+          lines.push(`- **${t.title}**${due}`);
+        });
+        lines.push('');
+      }
+
+      if (dueToday.length > 0) {
+        lines.push('## ✨ Quick Wins (Due Today)');
+        dueToday.forEach(t => {
+          lines.push(`- [ ] ${t.title} [${t.priority || 'medium'}]`);
+        });
+        lines.push('');
+      }
+
+      if (activeCount === 0) {
+        lines.push('## 🎉 All Done!');
+        lines.push('Nothing pending. Enjoy your day!');
+      }
+
+      return { content: [{ type: 'text', text: lines.join('\n') }] };
+    } catch (err) {
+      return { content: [{ type: 'text', text: `Error: ${err.message}` }], isError: true };
+    }
+  }
+);
+
+// ── Tool 7: break_down_task ──
+server.registerTool(
+  'break_down_task',
+  {
+    inputSchema: {
+      text: z.string().describe('Task description to break into steps'),
+    },
+  },
+  async (args) => {
+    const noClient = requireClient(); if (noClient) return noClient;
+    try {
+      const steps = breakDownTask(args.text);
+      const formatted = steps.map((s, i) => `${i + 1}. ${s}`).join('\n');
+      const lines = [];
+      lines.push(`Breakdown for: ${args.text}`);
+      lines.push('');
+      lines.push(formatted);
+
+      return {
+        content: [{
+          type: 'text',
+          text: lines.join('\n'),
+        }],
+      };
+    } catch (err) {
+      return { content: [{ type: 'text', text: `Error: ${err.message}` }], isError: true };
+    }
+  }
+);
+
+// ── Tool 8: reschedule ──
+server.registerTool(
+  'reschedule',
+  {
+    inputSchema: {},
+  },
+  async () => {
+    const noClient = requireClient(); if (noClient) return noClient;
+    try {
+      const data = await client.listTodos({});
+      const todos = data.todos || [];
+      const active = todos.filter(t => !t.completed && t.dueDate);
+
+      if (active.length === 0) {
+        return { content: [{ type: 'text', text: 'No scheduled tasks to reschedule.' }] };
+      }
+
+      const now = today();
+      const weekEnd = daysFromNow(7);
+      const monthEnd = daysFromNow(30);
+
+      const groups = {
+        'Due Today': [],
+        'Due This Week': [],
+        'Due This Month': [],
+        'No Rush': [],
+      };
+
+      for (const t of active) {
+        const due = new Date(t.dueDate);
+        due.setHours(0, 0, 0, 0);
+
+        if (isSameDay(due, now)) {
+          groups['Due Today'].push(t);
+        } else if (due <= weekEnd) {
+          groups['Due This Week'].push(t);
+        } else if (due <= monthEnd) {
+          groups['Due This Month'].push(t);
+        } else {
+          groups['No Rush'].push(t);
+        }
+      }
+
+      const lines = [];
+      lines.push('# 📅 Rescheduled View');
+      lines.push('');
+
+      for (const [groupName, groupTodos] of Object.entries(groups)) {
+        if (groupTodos.length === 0) continue;
+
+        groupTodos.sort((a, b) => {
+          const pa = PRIORITY_ORDER[a.priority] ?? 1;
+          const pb = PRIORITY_ORDER[b.priority] ?? 1;
+          return pa - pb;
+        });
+
+        const icon = groupName === 'Due Today' ? '🔴'
+          : groupName === 'Due This Week' ? '🟡'
+          : groupName === 'Due This Month' ? '🟢'
+          : '⚪';
+
+        lines.push(`## ${icon} ${groupName} (${groupTodos.length})`);
+        groupTodos.forEach(t => {
+          const due = new Date(t.dueDate).toLocaleDateString();
+          lines.push(`- **${t.title}** — due ${due} [${t.priority || 'medium'}]`);
+        });
+        lines.push('');
+      }
+
+      return {
+        content: [{
+          type: 'text',
+          text: lines.join('\n'),
+        }],
+      };
+    } catch (err) {
+      return { content: [{ type: 'text', text: `Error: ${err.message}` }], isError: true };
+    }
+  }
+);