todoist-mcp 1.2.1 → 1.2.2

package/dist/clients.d.ts

@@ -0,0 +1,4 @@
+import { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
+import { TodoistClient } from './utils/TodoistClient.js';
+export declare const todoistApi: TodoistClient;
+export declare const server: McpServer;

package/dist/clients.js

@@ -0,0 +1,10 @@
+import { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
+import { TodoistClient } from './utils/TodoistClient.js';
+import { config, version } from './utils/helpers.js';
+export const todoistApi = new TodoistClient(config.API_KEY);
+export const server = new McpServer({
+    name: 'todoist-mcp',
+    version,
+}, {
+    instructions: 'Use this server to interact with Todoist API',
+});

package/dist/index.d.ts

@@ -1,2 +1,4 @@
 #!/usr/bin/env node
+import './prompts.js';
+import './tools.js';
 export declare function main(): Promise<void>;

package/dist/index.js

@@ -1,53 +1,9 @@
 #!/usr/bin/env node
-import { Server } from '@modelcontextprotocol/sdk/server/index.js';
 import { StdioServerTransport } from '@modelcontextprotocol/sdk/server/stdio.js';
-import { CallToolRequestSchema, GetPromptRequestSchema, ListPromptsRequestSchema, ListToolsRequestSchema, } from '@modelcontextprotocol/sdk/types.js';
-import { ALL_PROMPT_HANDLERS, ALL_PROMPTS } from './prompts.js';
-import { ALL_HANDLERS, ALL_TOOLS } from './tools.js';
+import { server } from './clients.js';
 import { config, log } from './utils/helpers.js';
-import { version } from './utils/version.js';
-const server = new Server({
-    name: 'todoist-mcp',
-    version,
-}, { capabilities: { tools: {}, prompts: {} } });
-server.setRequestHandler(ListToolsRequestSchema, async () => {
-    return { tools: ALL_TOOLS };
-});
-server.setRequestHandler(ListPromptsRequestSchema, async () => {
-    return { prompts: ALL_PROMPTS };
-});
-server.setRequestHandler(CallToolRequestSchema, async (request) => {
-    const toolName = request.params.name;
-    log('Tool call: ', toolName);
-    try {
-        const handler = ALL_HANDLERS[toolName];
-        if (!handler) {
-            throw new Error(`Unknown tool: ${toolName}`);
-        }
-        return await handler(request);
-    }
-    catch (error) {
-        log('Error handling tool call:', error);
-        return {
-            content: [
-                {
-                    type: 'text',
-                    text: `Error: ${error instanceof Error ? error.message : String(error)}`,
-                },
-            ],
-            isError: true,
-        };
-    }
-});
-server.setRequestHandler(GetPromptRequestSchema, async (request) => {
-    const promptName = request.params.name;
-    log('Prompt call: ', promptName);
-    const handler = ALL_PROMPT_HANDLERS[promptName];
-    if (!handler) {
-        throw new Error(`Unknown prompt: ${promptName}`);
-    }
-    return await handler(request);
-});
+import './prompts.js';
+import './tools.js';
 export async function main() {
     if (!config.API_KEY || config.API_KEY.length === 0) {
         log('Missing required configuration: API_KEY');

package/dist/prompts/projects.d.ts

@@ -1,6 +1,4 @@
-import { PromptHandlers } from '../utils/types.js';
 export declare const PROJECT_LIST_PROMPT: {
     name: string;
     description: string;
 };
-export declare const PROJECT_LIST_RPOMPT_HANDLER: PromptHandlers;

package/dist/prompts/projects.js

@@ -1,67 +1,65 @@
-import { todoistApi } from '../utils/helpers.js';
+import { server, todoistApi } from '../clients.js';
 export const PROJECT_LIST_PROMPT = {
     name: 'projects_list',
     description: 'List of projects',
 };
-export const PROJECT_LIST_RPOMPT_HANDLER = {
-    projects_list: async () => {
-        const [projects, sections] = await Promise.all([
-            todoistApi.get('/projects'),
-            todoistApi.get('/sections'),
-        ]);
-        const sectionsByProject = sections.reduce((acc, section) => {
-            acc[section.project_id] = acc[section.project_id] || [];
-            acc[section.project_id].push(section);
-            return acc;
-        }, {});
-        const markdownParts = [
-            '# Todoist Projects Overview',
-            '',
-            `*Total Projects: ${projects.length}*`,
-            '',
-        ];
-        projects.forEach((project) => {
-            const projectSections = sectionsByProject[project.id] || [];
-            markdownParts.push(`## ${project.name}`);
-            markdownParts.push('| Property | Value |');
-            markdownParts.push('| -------- | ----- |');
-            markdownParts.push(`| ID | \`${project.id}\` |`);
-            markdownParts.push(`| Order | ${project.order} |`);
-            markdownParts.push(`| Parent ID | ${project.parent_id || 'None'} |`);
-            markdownParts.push(`| View Style | ${project.view_style} |`);
-            if (project.is_inbox_project)
-                markdownParts.push(`| Status | Inbox Project |`);
-            if (project.is_shared)
-                markdownParts.push(`| Sharing | Shared |`);
-            // if (project.url) markdownParts.push(`| URL | [Open in Todoist](${project.url}) |`);
-            if (project.description?.length > 0) {
-                const truncatedDescription = project.description.length > 100
-                    ? `${project.description.substring(0, 100).split(' ').slice(0, -1).join(' ')}...`
-                    : project.description;
-                markdownParts.push(`| Description | ${truncatedDescription} |`);
-            }
-            markdownParts.push('');
-            if (projectSections.length > 0) {
-                markdownParts.push(`### Sections (${projectSections.length})`);
-                projectSections.forEach(section => {
-                    markdownParts.push(`- **${section.name}** (ID: \`${section.id}\`)`);
-                });
-            }
-            else {
-                markdownParts.push('### Sections\n*No sections found*');
-            }
-            markdownParts.push('');
-        });
-        return {
-            messages: [
-                {
-                    role: 'user',
-                    content: {
-                        type: 'text',
-                        text: markdownParts.join('\n'),
-                    },
+server.prompt(PROJECT_LIST_PROMPT.name, {}, async () => {
+    const [projects, sections] = await Promise.all([
+        todoistApi.get('/projects'),
+        todoistApi.get('/sections'),
+    ]);
+    const sectionsByProject = sections.reduce((acc, section) => {
+        acc[section.project_id] = acc[section.project_id] || [];
+        acc[section.project_id].push(section);
+        return acc;
+    }, {});
+    const markdownParts = [
+        '# Todoist Projects Overview',
+        '',
+        `*Total Projects: ${projects.length}*`,
+        '',
+    ];
+    projects.forEach((project) => {
+        const projectSections = sectionsByProject[project.id] || [];
+        markdownParts.push(`## ${project.name}`);
+        markdownParts.push('| Property | Value |');
+        markdownParts.push('| -------- | ----- |');
+        markdownParts.push(`| ID | \`${project.id}\` |`);
+        markdownParts.push(`| Order | ${project.order} |`);
+        markdownParts.push(`| Parent ID | ${project.parent_id || 'None'} |`);
+        markdownParts.push(`| View Style | ${project.view_style} |`);
+        if (project.is_inbox_project)
+            markdownParts.push(`| Status | Inbox Project |`);
+        if (project.is_shared)
+            markdownParts.push(`| Sharing | Shared |`);
+        // if (project.url) markdownParts.push(`| URL | [Open in Todoist](${project.url}) |`);
+        if (project.description?.length > 0) {
+            const truncatedDescription = project.description.length > 100
+                ? `${project.description.substring(0, 100).split(' ').slice(0, -1).join(' ')}...`
+                : project.description;
+            markdownParts.push(`| Description | ${truncatedDescription} |`);
+        }
+        markdownParts.push('');
+        if (projectSections.length > 0) {
+            markdownParts.push(`### Sections (${projectSections.length})`);
+            projectSections.forEach(section => {
+                markdownParts.push(`- **${section.name}** (ID: \`${section.id}\`)`);
+            });
+        }
+        else {
+            markdownParts.push('### Sections\n*No sections found*');
+        }
+        markdownParts.push('');
+    });
+    return {
+        messages: [
+            {
+                role: 'user',
+                content: {
+                    type: 'text',
+                    text: markdownParts.join('\n'),
                 },
-            ],
-        };
-    },
-};
+            },
+        ],
+    };
+});

package/dist/prompts.d.ts

@@ -1,7 +1 @@
-export declare const ALL_PROMPTS: {
-    name: string;
-    description: string;
-}[];
-export declare const ALL_PROMPT_HANDLERS: {
-    [x: string]: (request: import("zod").TypeOf<typeof import("@modelcontextprotocol/sdk/types.js").GetPromptRequestSchema>) => Promise<import("./utils/types.js").PromptResult>;
-};
+import './prompts/projects.js';

package/dist/prompts.js

@@ -1,5 +1 @@
-import { PROJECT_LIST_PROMPT, PROJECT_LIST_RPOMPT_HANDLER } from './prompts/projects.js';
-export const ALL_PROMPTS = [PROJECT_LIST_PROMPT];
-export const ALL_PROMPT_HANDLERS = {
-    ...PROJECT_LIST_RPOMPT_HANDLER,
-};
+import './prompts/projects.js';

package/dist/tools/comments.d.ts

@@ -1,4 +1 @@
-import { Tool } from '@modelcontextprotocol/sdk/types.js';
-import { ToolHandlers } from '../utils/types.js';
-export declare const COMMENTS_TOOLS: Tool[];
-export declare const COMMENT_HANDLERS: ToolHandlers;
+export {};

package/dist/tools/comments.js

@@ -1,190 +1,59 @@
-import z from 'zod';
+import { z } from 'zod';
 import { createApiHandler, createBatchApiHandler } from '../utils/handlers.js';
-export const COMMENTS_TOOLS = [
-    {
-        name: 'get_comments_list',
-        description: 'Get all comments from Todoist',
-        inputSchema: {
-            type: 'object',
-            required: [],
-            properties: {
-                project_id: {
-                    type: 'string',
-                    description: 'ID of the project used to filter comments',
-                },
-                task_id: {
-                    type: 'string',
-                    description: 'ID of the task used to filter comments',
-                },
-            },
-            anyOf: [{ required: ['project_id'] }, { required: ['task_id'] }],
-        },
+createApiHandler({
+    name: 'get_comments_list',
+    description: 'Get comments list from Todoist',
+    schemaShape: {
+        project_id: z.string().optional().describe('Filter by project'),
+        task_id: z.string().optional().describe('Filter by task'),
     },
-    {
-        name: 'create_comments',
-        description: 'Create new comments in Todoist',
-        inputSchema: {
-            type: 'object',
-            required: ['items'],
-            properties: {
-                items: {
-                    type: 'array',
-                    description: 'Array of comment objects to create',
-                    items: {
-                        type: 'object',
-                        required: ['content'],
-                        properties: {
-                            task_id: {
-                                type: 'string',
-                                description: "Comment's task ID (for task comments)",
-                            },
-                            project_id: {
-                                type: 'string',
-                                description: "Comment's project ID (for project comments)",
-                            },
-                            content: {
-                                type: 'string',
-                                description: 'Comment markdown-formatted text and hyperlinks',
-                            },
-                            // attachment: {
-                            //     type: "object",
-                            //     description: 'Object for attachment object'
-                            // }
-                        },
-                        anyOf: [{ required: ['task_id'] }, { required: ['project_id'] }],
-                    },
-                },
-            },
-        },
+    method: 'GET',
+    path: '/comments',
+});
+createBatchApiHandler({
+    name: 'create_comments',
+    description: 'Create new comments in Todoist',
+    itemSchema: {
+        task_id: z.string().optional(),
+        project_id: z.string().optional(),
+        content: z.string().describe('Markdown-formatted text and hyperlinks'),
+        // attachment: z.object({}).optional(),
     },
-    {
-        name: 'get_comments',
-        description: 'Get comments from Todoist by ID',
-        inputSchema: {
-            type: 'object',
-            required: ['items'],
-            properties: {
-                items: {
-                    type: 'array',
-                    description: 'Array of comment identifiers to retrieve',
-                    items: {
-                        type: 'object',
-                        required: ['id'],
-                        properties: {
-                            id: {
-                                type: 'string',
-                                description: 'ID of the comment to retrieve',
-                            },
-                        },
-                    },
-                },
-            },
-        },
+    method: 'POST',
+    path: '/comments',
+    mode: 'create',
+});
+createBatchApiHandler({
+    name: 'get_comments',
+    description: 'Get comments from Todoist by ID',
+    itemSchema: {
+        id: z.string(),
     },
-    {
-        name: 'update_comments',
-        description: 'Update comments in Todoist',
-        inputSchema: {
-            type: 'object',
-            required: ['items'],
-            properties: {
-                items: {
-                    type: 'array',
-                    description: 'Array of comment objects to update',
-                    items: {
-                        type: 'object',
-                        required: ['id', 'content'],
-                        properties: {
-                            id: {
-                                type: 'string',
-                                description: 'ID of the comment to update',
-                            },
-                            content: {
-                                type: 'string',
-                                description: 'New content, markdown-formatted text and hyperlinks',
-                            },
-                        },
-                    },
-                },
-            },
-        },
+    method: 'GET',
+    path: '/comments/{id}',
+    mode: 'read',
+    idField: 'id',
+});
+createBatchApiHandler({
+    name: 'update_comments',
+    description: 'Update comments in Todoist',
+    itemSchema: {
+        id: z.string(),
+        content: z.string().describe('Markdown-formatted text and hyperlinks'),
     },
-    {
-        name: 'delete_comments',
-        description: 'Delete comments in Todoist',
-        inputSchema: {
-            type: 'object',
-            required: ['items'],
-            properties: {
-                items: {
-                    type: 'array',
-                    description: 'Array of comments to delete',
-                    items: {
-                        type: 'object',
-                        required: ['id'],
-                        properties: {
-                            id: {
-                                type: 'string',
-                                description: 'ID of the comment to delete',
-                            },
-                        },
-                    },
-                },
-            },
-        },
+    method: 'POST',
+    path: '/comments/{id}',
+    mode: 'update',
+    idField: 'id',
+});
+createBatchApiHandler({
+    name: 'delete_comments',
+    description: 'Delete comments in Todoist',
+    itemSchema: {
+        id: z.string(),
     },
-];
-export const COMMENT_HANDLERS = {
-    get_comments_list: createApiHandler({
-        schemaShape: {
-            project_id: z.string().optional(),
-            task_id: z.string().optional(),
-        },
-        method: 'GET',
-        path: '/comments',
-        errorPrefix: 'Failed to get comments',
-    }),
-    create_comments: createBatchApiHandler({
-        itemSchema: {
-            task_id: z.string().optional(),
-            project_id: z.string().optional(),
-            content: z.string(),
-            // attachment: z.object({}).optional(),
-        },
-        method: 'POST',
-        path: '/comments',
-        errorPrefix: 'Failed to create comments',
-        mode: 'create',
-    }),
-    get_comments: createBatchApiHandler({
-        itemSchema: {
-            id: z.string(),
-        },
-        method: 'GET',
-        path: '/comments/{id}',
-        errorPrefix: 'Failed to get comments',
-        mode: 'read',
-        idField: 'id',
-    }),
-    update_comments: createBatchApiHandler({
-        itemSchema: {
-            id: z.string(),
-            content: z.string(),
-        },
-        method: 'POST',
-        path: '/comments/{id}',
-        errorPrefix: 'Failed to update comments',
-        mode: 'update',
-        idField: 'id',
-    }),
-    delete_comments: createBatchApiHandler({
-        itemSchema: {
-            id: z.string(),
-        },
-        method: 'DELETE',
-        path: '/comments/{id}',
-        idField: 'id',
-        errorPrefix: 'Failed to delete comments',
-        mode: 'delete',
-    }),
-};
+    method: 'DELETE',
+    path: '/comments/{id}',
+    idField: 'id',
+    mode: 'delete',
+});

package/dist/tools/labels.d.ts

@@ -1,4 +1 @@
-import { Tool } from '@modelcontextprotocol/sdk/types.js';
-import { ToolHandlers } from '../utils/types.js';
-export declare const LABELS_TOOLS: Tool[];
-export declare const LABEL_HANDLERS: ToolHandlers;
+export {};