@kydycode/todoist-mcp-server-ext 0.1.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2024 Abhiram Nair
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,261 @@
+# Enhanced Todoist MCP Server Extended
+[![smithery badge](https://smithery.ai/badge/@abhiz123/todoist-mcp-server)](https://smithery.ai/server/@abhiz123/todoist-mcp-server)
+
+> **Extended Version** - Forked and enhanced by [kydycode](https://github.com/kydycode) from the original [@abhiz123/todoist-mcp-server](https://github.com/abhiz123/todoist-mcp-server)
+
+A comprehensive MCP (Model Context Protocol) server implementation that provides full integration between Claude and Todoist. This **extended version** includes additional features, improved compatibility, and enhanced functionality using the complete Todoist API with the latest MCP SDK.
+
+<a href="https://glama.ai/mcp/servers/fhaif4fv1w">
+  <img width="380" height="200" src="https://glama.ai/mcp/servers/fhaif4fv1w/badge" alt="Todoist Server MCP server" />
+</a>
+
+## 🆕 Extended Version Features
+
+### 🔧 **Technical Improvements**
+* **Updated MCP SDK Compatibility**: Compatible with MCP SDK 0.5.0 and latest versions
+* **Enhanced Error Handling**: Comprehensive error handling with detailed error messages
+* **Improved TypeScript Support**: Better type safety and compatibility
+* **Optimized API Usage**: Efficient use of Todoist API with proper parameter handling
+* **Better Response Formatting**: Enhanced task and project formatting for better readability
+
+### ✨ **Enhanced Task Management**
+* **Direct ID-based Operations**: Efficient task operations using task IDs instead of search
+* **Comprehensive Task Creation**: Support for subtasks, labels, projects, sections, priorities
+* **Quick Add Integration**: Natural language task creation using Todoist's Quick Add
+* **Advanced Task Search**: Content-based search with project scoping
+* **Task Movement Capabilities**: Move tasks between projects, sections, or make them subtasks
+* **Task State Management**: Complete, reopen, and manage task lifecycle
+* **Smart Filtering**: Enhanced filtering with better parameter handling
+
+### 🗂️ **Complete Project Management**
+* **Full Project CRUD**: Create, read, update, delete projects with all properties
+* **Sub-project Support**: Create hierarchical project structures
+* **Project Customization**: Set colors, favorites, view styles (list/board)
+* **Enhanced Project Listing**: Improved project retrieval and formatting
+
+### 📋 **Section Management**
+* **Complete Section Operations**: Create, read, update, delete sections
+* **Project-specific Sections**: Filter and manage sections within projects
+* **Section Organization**: Proper ordering and structure management
+
+## 🛠️ Available Tools
+
+### Task Operations (10 tools)
+| Tool | Description | Enhanced Features |
+|------|-------------|------------------|
+| `todoist_create_task` | Create tasks with full options | ✅ Subtasks, labels, projects, sections, priorities |
+| `todoist_quick_add_task` | Natural language task creation | ✅ Todoist Quick Add syntax support |
+| `todoist_get_tasks` | Retrieve tasks with filtering | ✅ Project, section, parent, label filtering |
+| `todoist_get_task` | Get specific task by ID | ✅ Direct ID-based retrieval |
+| `todoist_update_task` | Update task properties | ✅ Content, description, due date, priority, labels |
+| `todoist_delete_task` | Delete task by ID | ✅ Direct deletion with confirmation |
+| `todoist_complete_task` | Mark task complete | ✅ Instant completion |
+| `todoist_reopen_task` | Reopen completed task | ✅ Task restoration |
+| `todoist_search_tasks` | Search tasks by content | ✅ Project-scoped content search |
+
+### Project Operations (5 tools)
+| Tool | Description | Enhanced Features |
+|------|-------------|------------------|
+| `todoist_get_projects` | List all active projects | ✅ Clean formatting, proper error handling |
+| `todoist_get_project` | Get specific project by ID | ✅ Direct project retrieval |
+| `todoist_create_project` | Create new project | ✅ Name, color, favorite, view style, sub-projects |
+| `todoist_update_project` | Update project properties | ✅ All project attributes |
+| `todoist_delete_project` | Delete project by ID | ✅ Safe deletion with confirmation |
+
+### Section Operations (4 tools)
+| Tool | Description | Enhanced Features |
+|------|-------------|------------------|
+| `todoist_get_sections` | List sections | ✅ All sections or project-specific |
+| `todoist_create_section` | Create section in project | ✅ Name, project, ordering |
+| `todoist_update_section` | Update section name | ✅ Direct section modification |
+| `todoist_delete_section` | Delete section by ID | ✅ Clean section removal |
+
+## 🚀 Installation & Setup
+
+### Local Development Setup
+
+```bash
+# Clone the extended repository
+git clone https://github.com/kydycode/todoist-mcp-server-ext.git
+cd todoist-mcp-server-ext
+
+# Install dependencies
+npm install
+
+# Build the project
+npm run build
+```
+
+### Getting a Todoist API Token
+1. Log in to your Todoist account
+2. Navigate to Settings → Integrations → Developer
+3. Copy your API token
+
+### Usage with Claude Desktop
+
+Add to your `claude_desktop_config.json`:
+
+#### Option 1: Run locally built version
+```json
+{
+  "mcpServers": {
+    "todoist-mcp-server": {
+      "command": "node",
+      "args": ["/path/to/todoist-mcp-server-ext/dist/index.js"],
+      "env": {
+        "TODOIST_API_TOKEN": "your_api_token_here"
+      }
+    }
+  }
+}
+```
+
+#### Option 2: Run via npm (if installed globally)
+```json
+{
+  "mcpServers": {
+    "todoist-mcp-server": {
+      "command": "npx",
+      "args": ["-y", "@kydycode/todoist-mcp-server-ext"],
+      "env": {
+        "TODOIST_API_TOKEN": "your_api_token_here"
+      }
+    }
+  }
+}
+```
+
+#### Option 3: Install globally first
+```bash
+# Install the extended version globally
+npm install -g @kydycode/todoist-mcp-server-ext
+
+# Then use in Claude Desktop config
+{
+  "mcpServers": {
+    "todoist-mcp-server": {
+      "command": "todoist-mcp-server-ext",
+      "env": {
+        "TODOIST_API_TOKEN": "your_api_token_here"
+      }
+    }
+  }
+}
+```
+
+## 📖 Usage Examples
+
+### 🎯 Advanced Task Creation
+```
+"Create task 'Team Meeting' in project 'Work'"
+"Add high priority task 'Fix critical bug' with labels 'urgent' and 'backend'"
+"Quick add: 'Buy milk tomorrow at 2pm #shopping !p1'"
+"Create subtask 'Prepare agenda' under existing task"
+```
+
+### 🔍 Task Management & Search
+```
+"Get all tasks in project 'Work'"
+"Search for tasks containing 'meeting'"
+"Show task details for specific task ID"
+"Update task priority to urgent"
+"Complete task and then reopen it"
+```
+
+### 🗂️ Project Organization
+```
+"List all my projects"
+"Create project 'Q1 Planning' with blue color and board view"
+"Create sub-project 'Marketing' under 'Business'"
+"Update project to favorite"
+"Get specific project details"
+```
+
+### 📋 Section Management
+```
+"Create section 'In Progress' in Development project"
+"List all sections in Work project"
+"Update section name to 'Completed'"
+"Delete empty section"
+```
+
+## 🆚 Extended vs Original Comparison
+
+| Feature | Original | Extended Version |
+|---------|----------|------------------|
+| **MCP SDK Compatibility** | Older version | ✅ Latest MCP SDK 0.5.0+ |
+| **Error Handling** | Basic | ✅ Comprehensive with detailed messages |
+| **TypeScript Support** | Limited | ✅ Full type safety |
+| **Task Operations** | Search-based | ✅ Direct ID-based + Search fallback |
+| **Project Management** | Limited | ✅ Full CRUD operations |
+| **Section Management** | Basic | ✅ Complete section operations |
+| **API Parameter Handling** | Inconsistent | ✅ Proper parameter validation |
+| **Response Formatting** | Basic | ✅ Enhanced readability |
+| **Build System** | Issues | ✅ Clean compilation |
+
+## 🔧 Development
+
+### Project Structure
+```
+src/
+├── index.ts          # Main server implementation with all tools
+├── package.json      # Dependencies and scripts
+├── tsconfig.json     # TypeScript configuration
+└── dist/            # Compiled JavaScript output
+    ├── index.js
+    └── index.d.ts
+```
+
+### Building from Source
+```bash
+# Install dependencies
+npm install
+
+# Build TypeScript
+npm run build
+
+# Test the server (requires TODOIST_API_TOKEN)
+TODOIST_API_TOKEN=your_token node dist/index.js
+```
+
+### Development Scripts
+```bash
+npm run build     # Compile TypeScript
+npm run watch     # Watch for changes and rebuild
+npm run prepare   # Pre-publish build
+```
+
+## 🤝 Contributing
+
+Contributions are welcome! This extended version accepts contributions for:
+
+- Additional Todoist API endpoints
+- Enhanced error handling and validation
+- Performance optimizations
+- Documentation improvements
+- Bug fixes and compatibility updates
+
+Please submit issues and pull requests to the [extended repository](https://github.com/kydycode/todoist-mcp-server-ext).
+
+## 📄 License
+
+This project is licensed under the MIT License - see the [LICENSE](LICENSE) file for details.
+
+## 🙏 Credits
+
+- **Extended Version**: [kydycode](https://github.com/kydycode) - Enhanced functionality and compatibility
+- **Original Creator**: [@abhiz123](https://github.com/abhiz123) - Initial Todoist MCP server implementation
+- **MCP Protocol**: [Model Context Protocol](https://modelcontextprotocol.io/) by Anthropic
+
+## 🐛 Issues and Support
+
+- **Extended Version Issues**: [GitHub Issues](https://github.com/kydycode/todoist-mcp-server-ext/issues)
+- **Original Repository**: [abhiz123/todoist-mcp-server](https://github.com/abhiz123/todoist-mcp-server)
+
+## 🔗 Related Links
+
+- **Extended Repository**: [kydycode/todoist-mcp-server-ext](https://github.com/kydycode/todoist-mcp-server-ext)
+- **Original Repository**: [abhiz123/todoist-mcp-server](https://github.com/abhiz123/todoist-mcp-server)
+- [Todoist API Documentation](https://developer.todoist.com/)
+- [Model Context Protocol](https://modelcontextprotocol.io/)
+- [Claude Desktop](https://claude.ai/download)

package/dist/index.d.ts

@@ -0,0 +1,2 @@
+#!/usr/bin/env node
+export {};

package/dist/index.js

@@ -0,0 +1,918 @@
+#!/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 { TodoistApi } from "@doist/todoist-api-typescript";
+// Check for API token
+const TODOIST_API_TOKEN = process.env.TODOIST_API_TOKEN;
+if (!TODOIST_API_TOKEN) {
+    console.error("Error: TODOIST_API_TOKEN environment variable is required");
+    process.exit(1);
+}
+// Initialize Todoist client
+const todoistClient = new TodoistApi(TODOIST_API_TOKEN);
+// Enhanced Task Tools
+const CREATE_TASK_TOOL = {
+    name: "todoist_create_task",
+    description: "Create a new task in Todoist with comprehensive options including subtasks",
+    inputSchema: {
+        type: "object",
+        properties: {
+            content: {
+                type: "string",
+                description: "The content/title of the task"
+            },
+            description: {
+                type: "string",
+                description: "Detailed description of the task (optional)"
+            },
+            projectId: {
+                type: "string",
+                description: "Project ID to create the task in (optional)"
+            },
+            sectionId: {
+                type: "string",
+                description: "Section ID to create the task in (optional)"
+            },
+            parentId: {
+                type: "string",
+                description: "Parent task ID to create this as a subtask (optional)"
+            },
+            dueString: {
+                type: "string",
+                description: "Natural language due date like 'tomorrow', 'next Monday', 'Jan 23' (optional)"
+            },
+            priority: {
+                type: "number",
+                description: "Task priority from 1 (normal) to 4 (urgent) (optional)",
+                enum: [1, 2, 3, 4]
+            },
+            labels: {
+                type: "array",
+                items: { type: "string" },
+                description: "Array of label names to assign to the task (optional)"
+            }
+        },
+        required: ["content"]
+    }
+};
+const QUICK_ADD_TASK_TOOL = {
+    name: "todoist_quick_add_task",
+    description: "Create a task using Todoist's Quick Add feature with natural language parsing",
+    inputSchema: {
+        type: "object",
+        properties: {
+            text: {
+                type: "string",
+                description: "Natural language text for quick task creation (e.g., 'Buy milk tomorrow at 2pm #shopping')"
+            },
+            note: {
+                type: "string",
+                description: "Additional note for the task (optional)"
+            },
+            reminder: {
+                type: "string",
+                description: "Reminder time (optional)"
+            }
+        },
+        required: ["text"]
+    }
+};
+const GET_TASKS_TOOL = {
+    name: "todoist_get_tasks",
+    description: "Get tasks with comprehensive filtering and pagination support",
+    inputSchema: {
+        type: "object",
+        properties: {
+            projectId: {
+                type: "string",
+                description: "Filter tasks by project ID (optional)"
+            },
+            sectionId: {
+                type: "string",
+                description: "Filter tasks by section ID (optional)"
+            },
+            parentId: {
+                type: "string",
+                description: "Filter tasks by parent ID (get subtasks) (optional)"
+            },
+            label: {
+                type: "string",
+                description: "Filter tasks by label name (optional)"
+            },
+            ids: {
+                type: "array",
+                items: { type: "string" },
+                description: "Array of task IDs to retrieve (optional)"
+            },
+            cursor: {
+                type: "string",
+                description: "Pagination cursor for next page (optional)"
+            },
+            limit: {
+                type: "number",
+                description: "Maximum number of tasks to return (default: 50, max: 200) (optional)",
+                default: 50
+            }
+        }
+    }
+};
+const GET_TASK_TOOL = {
+    name: "todoist_get_task",
+    description: "Get a specific task by its ID",
+    inputSchema: {
+        type: "object",
+        properties: {
+            taskId: {
+                type: "string",
+                description: "The ID of the task to retrieve"
+            }
+        },
+        required: ["taskId"]
+    }
+};
+const UPDATE_TASK_TOOL = {
+    name: "todoist_update_task",
+    description: "Update an existing task by its ID",
+    inputSchema: {
+        type: "object",
+        properties: {
+            taskId: {
+                type: "string",
+                description: "The ID of the task to update"
+            },
+            content: {
+                type: "string",
+                description: "New content/title for the task (optional)"
+            },
+            description: {
+                type: "string",
+                description: "New description for the task (optional)"
+            },
+            dueString: {
+                type: "string",
+                description: "New due date in natural language (optional)"
+            },
+            priority: {
+                type: "number",
+                description: "New priority level from 1 (normal) to 4 (urgent) (optional)",
+                enum: [1, 2, 3, 4]
+            },
+            labels: {
+                type: "array",
+                items: { type: "string" },
+                description: "New array of label names (optional)"
+            }
+        },
+        required: ["taskId"]
+    }
+};
+const DELETE_TASK_TOOL = {
+    name: "todoist_delete_task",
+    description: "Delete a task by its ID",
+    inputSchema: {
+        type: "object",
+        properties: {
+            taskId: {
+                type: "string",
+                description: "The ID of the task to delete"
+            }
+        },
+        required: ["taskId"]
+    }
+};
+const COMPLETE_TASK_TOOL = {
+    name: "todoist_complete_task",
+    description: "Mark a task as complete by its ID",
+    inputSchema: {
+        type: "object",
+        properties: {
+            taskId: {
+                type: "string",
+                description: "The ID of the task to complete"
+            }
+        },
+        required: ["taskId"]
+    }
+};
+const REOPEN_TASK_TOOL = {
+    name: "todoist_reopen_task",
+    description: "Reopen a completed task by its ID",
+    inputSchema: {
+        type: "object",
+        properties: {
+            taskId: {
+                type: "string",
+                description: "The ID of the completed task to reopen"
+            }
+        },
+        required: ["taskId"]
+    }
+};
+// Project Management Tools
+const GET_PROJECTS_TOOL = {
+    name: "todoist_get_projects",
+    description: "Get all active projects with pagination support",
+    inputSchema: {
+        type: "object",
+        properties: {
+            cursor: {
+                type: "string",
+                description: "Pagination cursor for next page (optional)"
+            },
+            limit: {
+                type: "number",
+                description: "Maximum number of projects to return (default: 50, max: 200) (optional)",
+                default: 50
+            }
+        }
+    }
+};
+const GET_PROJECT_TOOL = {
+    name: "todoist_get_project",
+    description: "Get a specific project by its ID",
+    inputSchema: {
+        type: "object",
+        properties: {
+            projectId: {
+                type: "string",
+                description: "The ID of the project to retrieve"
+            }
+        },
+        required: ["projectId"]
+    }
+};
+const CREATE_PROJECT_TOOL = {
+    name: "todoist_create_project",
+    description: "Create a new project",
+    inputSchema: {
+        type: "object",
+        properties: {
+            name: {
+                type: "string",
+                description: "The name of the project"
+            },
+            parentId: {
+                type: "string",
+                description: "Parent project ID for creating a sub-project (optional)"
+            },
+            color: {
+                type: "string",
+                description: "Project color (optional)"
+            },
+            isFavorite: {
+                type: "boolean",
+                description: "Whether to mark as favorite (optional)"
+            },
+            viewStyle: {
+                type: "string",
+                description: "Project view style: 'list' or 'board' (optional)",
+                enum: ["list", "board"]
+            }
+        },
+        required: ["name"]
+    }
+};
+const UPDATE_PROJECT_TOOL = {
+    name: "todoist_update_project",
+    description: "Update an existing project",
+    inputSchema: {
+        type: "object",
+        properties: {
+            projectId: {
+                type: "string",
+                description: "The ID of the project to update"
+            },
+            name: {
+                type: "string",
+                description: "New name for the project (optional)"
+            },
+            color: {
+                type: "string",
+                description: "New color for the project (optional)"
+            },
+            isFavorite: {
+                type: "boolean",
+                description: "Whether to mark as favorite (optional)"
+            },
+            viewStyle: {
+                type: "string",
+                description: "Project view style: 'list' or 'board' (optional)",
+                enum: ["list", "board"]
+            }
+        },
+        required: ["projectId"]
+    }
+};
+const DELETE_PROJECT_TOOL = {
+    name: "todoist_delete_project",
+    description: "Delete a project by its ID",
+    inputSchema: {
+        type: "object",
+        properties: {
+            projectId: {
+                type: "string",
+                description: "The ID of the project to delete"
+            }
+        },
+        required: ["projectId"]
+    }
+};
+// Section Management Tools
+const GET_SECTIONS_TOOL = {
+    name: "todoist_get_sections",
+    description: "Get all sections or sections for a specific project",
+    inputSchema: {
+        type: "object",
+        properties: {
+            projectId: {
+                type: "string",
+                description: "Filter sections by project ID (optional)"
+            }
+        }
+    }
+};
+const CREATE_SECTION_TOOL = {
+    name: "todoist_create_section",
+    description: "Create a new section in a project",
+    inputSchema: {
+        type: "object",
+        properties: {
+            name: {
+                type: "string",
+                description: "The name of the section"
+            },
+            projectId: {
+                type: "string",
+                description: "The project ID where the section will be created"
+            },
+            order: {
+                type: "number",
+                description: "Order of the section (optional)"
+            }
+        },
+        required: ["name", "projectId"]
+    }
+};
+const UPDATE_SECTION_TOOL = {
+    name: "todoist_update_section",
+    description: "Update an existing section",
+    inputSchema: {
+        type: "object",
+        properties: {
+            sectionId: {
+                type: "string",
+                description: "The ID of the section to update"
+            },
+            name: {
+                type: "string",
+                description: "New name for the section"
+            }
+        },
+        required: ["sectionId", "name"]
+    }
+};
+const DELETE_SECTION_TOOL = {
+    name: "todoist_delete_section",
+    description: "Delete a section by its ID",
+    inputSchema: {
+        type: "object",
+        properties: {
+            sectionId: {
+                type: "string",
+                description: "The ID of the section to delete"
+            }
+        },
+        required: ["sectionId"]
+    }
+};
+// Search Tool
+const SEARCH_TASKS_TOOL = {
+    name: "todoist_search_tasks",
+    description: "Search for tasks by content/name (fallback for when ID is not known)",
+    inputSchema: {
+        type: "object",
+        properties: {
+            query: {
+                type: "string",
+                description: "Search query to find tasks by content"
+            },
+            projectId: {
+                type: "string",
+                description: "Limit search to specific project (optional)"
+            },
+            limit: {
+                type: "number",
+                description: "Maximum number of results (default: 10) (optional)",
+                default: 10
+            }
+        },
+        required: ["query"]
+    }
+};
+// Server implementation
+const server = new Server({
+    name: "todoist-mcp-server-enhanced",
+    version: "0.2.0",
+}, {
+    capabilities: {
+        tools: {},
+    },
+});
+// Helper function to format task output
+function formatTask(task) {
+    return `- ${task.content}${task.description ? `\n  Description: ${task.description}` : ''}${task.due ? `\n  Due: ${task.due.string}` : ''}${task.priority && task.priority > 1 ? `\n  Priority: ${task.priority}` : ''}${task.labels && task.labels.length > 0 ? `\n  Labels: ${task.labels.join(', ')}` : ''}${task.parentId ? `\n  Parent: ${task.parentId}` : ''}`;
+}
+// Helper function to format project output
+function formatProject(project) {
+    return `- ${project.name}${project.color ? `\n  Color: ${project.color}` : ''}${project.isFavorite ? `\n  Favorite: Yes` : ''}${project.viewStyle ? `\n  View: ${project.viewStyle}` : ''}${project.parentId ? `\n  Parent: ${project.parentId}` : ''}`;
+}
+// Type guards for arguments
+function isCreateTaskArgs(args) {
+    return (typeof args === "object" &&
+        args !== null &&
+        "content" in args &&
+        typeof args.content === "string");
+}
+function isQuickAddArgs(args) {
+    return (typeof args === "object" &&
+        args !== null &&
+        "text" in args &&
+        typeof args.text === "string");
+}
+function isGetTasksArgs(args) {
+    return typeof args === "object" && args !== null;
+}
+function isTaskIdArgs(args) {
+    return (typeof args === "object" &&
+        args !== null &&
+        "taskId" in args &&
+        typeof args.taskId === "string");
+}
+function isUpdateTaskArgs(args) {
+    return (typeof args === "object" &&
+        args !== null &&
+        "taskId" in args &&
+        typeof args.taskId === "string");
+}
+function isProjectArgs(args) {
+    return typeof args === "object" && args !== null;
+}
+function isProjectIdArgs(args) {
+    return (typeof args === "object" &&
+        args !== null &&
+        "projectId" in args &&
+        typeof args.projectId === "string");
+}
+function isCreateProjectArgs(args) {
+    return (typeof args === "object" &&
+        args !== null &&
+        "name" in args &&
+        typeof args.name === "string");
+}
+function isUpdateProjectArgs(args) {
+    return (typeof args === "object" &&
+        args !== null &&
+        "projectId" in args &&
+        typeof args.projectId === "string");
+}
+function isSectionArgs(args) {
+    return typeof args === "object" && args !== null;
+}
+function isCreateSectionArgs(args) {
+    return (typeof args === "object" &&
+        args !== null &&
+        "name" in args &&
+        "projectId" in args &&
+        typeof args.name === "string" &&
+        typeof args.projectId === "string");
+}
+function isUpdateSectionArgs(args) {
+    return (typeof args === "object" &&
+        args !== null &&
+        "sectionId" in args &&
+        "name" in args &&
+        typeof args.sectionId === "string" &&
+        typeof args.name === "string");
+}
+function isSectionIdArgs(args) {
+    return (typeof args === "object" &&
+        args !== null &&
+        "sectionId" in args &&
+        typeof args.sectionId === "string");
+}
+function isSearchTasksArgs(args) {
+    return (typeof args === "object" &&
+        args !== null &&
+        "query" in args &&
+        typeof args.query === "string");
+}
+// Tool handlers
+server.setRequestHandler(ListToolsRequestSchema, async () => ({
+    tools: [
+        // Task tools
+        CREATE_TASK_TOOL,
+        QUICK_ADD_TASK_TOOL,
+        GET_TASKS_TOOL,
+        GET_TASK_TOOL,
+        UPDATE_TASK_TOOL,
+        DELETE_TASK_TOOL,
+        COMPLETE_TASK_TOOL,
+        REOPEN_TASK_TOOL,
+        SEARCH_TASKS_TOOL,
+        // Project tools
+        GET_PROJECTS_TOOL,
+        GET_PROJECT_TOOL,
+        CREATE_PROJECT_TOOL,
+        UPDATE_PROJECT_TOOL,
+        DELETE_PROJECT_TOOL,
+        // Section tools
+        GET_SECTIONS_TOOL,
+        CREATE_SECTION_TOOL,
+        UPDATE_SECTION_TOOL,
+        DELETE_SECTION_TOOL,
+    ],
+}));
+server.setRequestHandler(CallToolRequestSchema, async (request) => {
+    try {
+        const { name, arguments: args } = request.params;
+        if (!args) {
+            throw new Error("No arguments provided");
+        }
+        // Task operations
+        if (name === "todoist_create_task") {
+            if (!isCreateTaskArgs(args)) {
+                throw new Error("Invalid arguments for todoist_create_task");
+            }
+            const taskData = {
+                content: args.content,
+            };
+            if (args.description)
+                taskData.description = args.description;
+            if (args.projectId)
+                taskData.projectId = args.projectId;
+            if (args.sectionId)
+                taskData.sectionId = args.sectionId;
+            if (args.parentId)
+                taskData.parentId = args.parentId;
+            if (args.dueString)
+                taskData.dueString = args.dueString;
+            if (args.priority)
+                taskData.priority = args.priority;
+            if (args.labels && args.labels.length > 0)
+                taskData.labels = args.labels;
+            const task = await todoistClient.addTask(taskData);
+            return {
+                content: [{
+                        type: "text",
+                        text: `Task created successfully:\nID: ${task.id}\n${formatTask(task)}`
+                    }],
+                isError: false,
+            };
+        }
+        if (name === "todoist_quick_add_task") {
+            if (!isQuickAddArgs(args)) {
+                throw new Error("Invalid arguments for todoist_quick_add_task");
+            }
+            const quickAddData = { text: args.text };
+            if (args.note)
+                quickAddData.note = args.note;
+            if (args.reminder)
+                quickAddData.reminder = args.reminder;
+            const result = await todoistClient.quickAddTask(quickAddData);
+            return {
+                content: [{
+                        type: "text",
+                        text: `Task created via Quick Add:\n${JSON.stringify(result, null, 2)}`
+                    }],
+                isError: false,
+            };
+        }
+        if (name === "todoist_get_tasks") {
+            if (!isGetTasksArgs(args)) {
+                throw new Error("Invalid arguments for todoist_get_tasks");
+            }
+            const params = {};
+            if (args.projectId)
+                params.projectId = args.projectId;
+            if (args.sectionId)
+                params.sectionId = args.sectionId;
+            if (args.parentId)
+                params.parentId = args.parentId;
+            if (args.label)
+                params.label = args.label;
+            if (args.ids && args.ids.length > 0)
+                params.ids = args.ids;
+            if (args.cursor)
+                params.cursor = args.cursor;
+            if (args.limit)
+                params.limit = args.limit;
+            const tasks = await todoistClient.getTasks(Object.keys(params).length > 0 ? params : {});
+            // Handle both array and paginated response formats
+            let taskList;
+            let nextCursor = '';
+            if (Array.isArray(tasks)) {
+                taskList = tasks.map(formatTask).join('\n\n');
+            }
+            else {
+                const paginatedTasks = tasks;
+                taskList = paginatedTasks.results?.map(formatTask).join('\n\n') || 'No tasks found';
+                nextCursor = paginatedTasks.nextCursor ? `\n\nNext cursor: ${paginatedTasks.nextCursor}` : '';
+            }
+            return {
+                content: [{
+                        type: "text",
+                        text: `Tasks:\n${taskList}${nextCursor}`
+                    }],
+                isError: false,
+            };
+        }
+        if (name === "todoist_get_task") {
+            if (!isTaskIdArgs(args)) {
+                throw new Error("Invalid arguments for todoist_get_task");
+            }
+            const task = await todoistClient.getTask(args.taskId);
+            return {
+                content: [{
+                        type: "text",
+                        text: `Task details:\nID: ${task.id}\n${formatTask(task)}`
+                    }],
+                isError: false,
+            };
+        }
+        if (name === "todoist_update_task") {
+            if (!isUpdateTaskArgs(args)) {
+                throw new Error("Invalid arguments for todoist_update_task");
+            }
+            const updateData = {};
+            if (args.content)
+                updateData.content = args.content;
+            if (args.description)
+                updateData.description = args.description;
+            if (args.dueString)
+                updateData.dueString = args.dueString;
+            if (args.priority)
+                updateData.priority = args.priority;
+            if (args.labels)
+                updateData.labels = args.labels;
+            const updatedTask = await todoistClient.updateTask(args.taskId, updateData);
+            return {
+                content: [{
+                        type: "text",
+                        text: `Task updated successfully:\nID: ${updatedTask.id}\n${formatTask(updatedTask)}`
+                    }],
+                isError: false,
+            };
+        }
+        if (name === "todoist_delete_task") {
+            if (!isTaskIdArgs(args)) {
+                throw new Error("Invalid arguments for todoist_delete_task");
+            }
+            await todoistClient.deleteTask(args.taskId);
+            return {
+                content: [{
+                        type: "text",
+                        text: `Task ${args.taskId} deleted successfully`
+                    }],
+                isError: false,
+            };
+        }
+        if (name === "todoist_complete_task") {
+            if (!isTaskIdArgs(args)) {
+                throw new Error("Invalid arguments for todoist_complete_task");
+            }
+            await todoistClient.closeTask(args.taskId);
+            return {
+                content: [{
+                        type: "text",
+                        text: `Task ${args.taskId} completed successfully`
+                    }],
+                isError: false,
+            };
+        }
+        if (name === "todoist_reopen_task") {
+            if (!isTaskIdArgs(args)) {
+                throw new Error("Invalid arguments for todoist_reopen_task");
+            }
+            await todoistClient.reopenTask(args.taskId);
+            return {
+                content: [{
+                        type: "text",
+                        text: `Task ${args.taskId} reopened successfully`
+                    }],
+                isError: false,
+            };
+        }
+        if (name === "todoist_search_tasks") {
+            if (!isSearchTasksArgs(args)) {
+                throw new Error("Invalid arguments for todoist_search_tasks");
+            }
+            const params = {};
+            if (args.projectId)
+                params.projectId = args.projectId;
+            const tasks = await todoistClient.getTasks(params);
+            const allTasks = Array.isArray(tasks) ? tasks : tasks.results || [];
+            const matchingTasks = allTasks.filter((task) => task.content.toLowerCase().includes(args.query.toLowerCase())).slice(0, args.limit || 10);
+            if (matchingTasks.length === 0) {
+                return {
+                    content: [{
+                            type: "text",
+                            text: `No tasks found matching "${args.query}"`
+                        }],
+                    isError: false,
+                };
+            }
+            const taskList = matchingTasks.map((task) => `ID: ${task.id}\n${formatTask(task)}`).join('\n\n');
+            return {
+                content: [{
+                        type: "text",
+                        text: `Found ${matchingTasks.length} task(s) matching "${args.query}":\n\n${taskList}`
+                    }],
+                isError: false,
+            };
+        }
+        // Project operations
+        if (name === "todoist_get_projects") {
+            if (!isProjectArgs(args)) {
+                throw new Error("Invalid arguments for todoist_get_projects");
+            }
+            const params = {};
+            if (args.cursor)
+                params.cursor = args.cursor;
+            if (args.limit)
+                params.limit = args.limit;
+            // Note: getProjects() may not accept parameters in this API version
+            const projects = await todoistClient.getProjects();
+            // Handle simple array response
+            const projectList = Array.isArray(projects)
+                ? projects.map(formatProject).join('\n\n')
+                : 'No projects found';
+            return {
+                content: [{
+                        type: "text",
+                        text: `Projects:\n${projectList}`
+                    }],
+                isError: false,
+            };
+        }
+        if (name === "todoist_get_project") {
+            if (!isProjectIdArgs(args)) {
+                throw new Error("Invalid arguments for todoist_get_project");
+            }
+            const project = await todoistClient.getProject(args.projectId);
+            return {
+                content: [{
+                        type: "text",
+                        text: `Project details:\nID: ${project.id}\n${formatProject(project)}`
+                    }],
+                isError: false,
+            };
+        }
+        if (name === "todoist_create_project") {
+            if (!isCreateProjectArgs(args)) {
+                throw new Error("Invalid arguments for todoist_create_project");
+            }
+            const projectData = { name: args.name };
+            if (args.parentId)
+                projectData.parentId = args.parentId;
+            if (args.color)
+                projectData.color = args.color;
+            if (args.isFavorite !== undefined)
+                projectData.isFavorite = args.isFavorite;
+            if (args.viewStyle)
+                projectData.viewStyle = args.viewStyle;
+            const project = await todoistClient.addProject(projectData);
+            return {
+                content: [{
+                        type: "text",
+                        text: `Project created successfully:\nID: ${project.id}\n${formatProject(project)}`
+                    }],
+                isError: false,
+            };
+        }
+        if (name === "todoist_update_project") {
+            if (!isUpdateProjectArgs(args)) {
+                throw new Error("Invalid arguments for todoist_update_project");
+            }
+            const updateData = {};
+            if (args.name)
+                updateData.name = args.name;
+            if (args.color)
+                updateData.color = args.color;
+            if (args.isFavorite !== undefined)
+                updateData.isFavorite = args.isFavorite;
+            if (args.viewStyle)
+                updateData.viewStyle = args.viewStyle;
+            const updatedProject = await todoistClient.updateProject(args.projectId, updateData);
+            return {
+                content: [{
+                        type: "text",
+                        text: `Project updated successfully:\nID: ${updatedProject.id}\n${formatProject(updatedProject)}`
+                    }],
+                isError: false,
+            };
+        }
+        if (name === "todoist_delete_project") {
+            if (!isProjectIdArgs(args)) {
+                throw new Error("Invalid arguments for todoist_delete_project");
+            }
+            await todoistClient.deleteProject(args.projectId);
+            return {
+                content: [{
+                        type: "text",
+                        text: `Project ${args.projectId} deleted successfully`
+                    }],
+                isError: false,
+            };
+        }
+        // Section operations
+        if (name === "todoist_get_sections") {
+            if (!isSectionArgs(args)) {
+                throw new Error("Invalid arguments for todoist_get_sections");
+            }
+            const params = {};
+            if (args.projectId)
+                params.projectId = args.projectId;
+            const sections = await todoistClient.getSections(Object.keys(params).length > 0 ? params : {});
+            // Handle simple array response
+            const sectionResults = Array.isArray(sections) ? sections : [];
+            const sectionList = sectionResults.map((section) => `- ${section.name} (ID: ${section.id}, Project: ${section.projectId})`).join('\n');
+            return {
+                content: [{
+                        type: "text",
+                        text: `Sections:\n${sectionList || 'No sections found'}`
+                    }],
+                isError: false,
+            };
+        }
+        if (name === "todoist_create_section") {
+            if (!isCreateSectionArgs(args)) {
+                throw new Error("Invalid arguments for todoist_create_section");
+            }
+            const sectionData = {
+                name: args.name,
+                projectId: args.projectId
+            };
+            if (args.order !== undefined)
+                sectionData.order = args.order;
+            const section = await todoistClient.addSection(sectionData);
+            return {
+                content: [{
+                        type: "text",
+                        text: `Section created successfully:\nID: ${section.id}\nName: ${section.name}\nProject: ${section.projectId}`
+                    }],
+                isError: false,
+            };
+        }
+        if (name === "todoist_update_section") {
+            if (!isUpdateSectionArgs(args)) {
+                throw new Error("Invalid arguments for todoist_update_section");
+            }
+            const updatedSection = await todoistClient.updateSection(args.sectionId, { name: args.name });
+            return {
+                content: [{
+                        type: "text",
+                        text: `Section updated successfully:\nID: ${updatedSection.id}\nName: ${updatedSection.name}`
+                    }],
+                isError: false,
+            };
+        }
+        if (name === "todoist_delete_section") {
+            if (!isSectionIdArgs(args)) {
+                throw new Error("Invalid arguments for todoist_delete_section");
+            }
+            await todoistClient.deleteSection(args.sectionId);
+            return {
+                content: [{
+                        type: "text",
+                        text: `Section ${args.sectionId} deleted successfully`
+                    }],
+                isError: false,
+            };
+        }
+        return {
+            content: [{ type: "text", text: `Unknown tool: ${name}` }],
+            isError: true,
+        };
+    }
+    catch (error) {
+        return {
+            content: [
+                {
+                    type: "text",
+                    text: `Error: ${error instanceof Error ? error.message : String(error)}`,
+                },
+            ],
+            isError: true,
+        };
+    }
+});
+async function runServer() {
+    const transport = new StdioServerTransport();
+    await server.connect(transport);
+    console.error("Enhanced Todoist MCP Server running on stdio");
+}
+runServer().catch((error) => {
+    console.error("Fatal error running server:", error);
+    process.exit(1);
+});

package/package.json

@@ -0,0 +1,49 @@
+{
+  "name": "@kydycode/todoist-mcp-server-ext",
+  "version": "0.1.0",
+  "description": "Extended MCP server for Todoist API integration with enhanced features and improved compatibility",
+  "main": "dist/index.js",
+  "types": "dist/index.d.ts",
+  "type": "module",
+  "bin": {
+    "todoist-mcp-server-ext": "dist/index.js"
+  },
+  "files": [
+    "dist"
+  ],
+  "scripts": {
+    "build": "tsc && shx chmod +x dist/*.js",
+    "prepare": "npm run build",
+    "watch": "tsc --watch"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/kydycode/todoist-mcp-server-ext.git"
+  },
+  "keywords": [
+    "mcp",
+    "todoist",
+    "claude",
+    "ai",
+    "task-management",
+    "extended",
+    "enhanced",
+    "kydycode"
+  ],
+  "author": "kydycode (extended version) - Original by abhiz123",
+  "license": "MIT",
+  "bugs": {
+    "url": "https://github.com/kydycode/todoist-mcp-server-ext/issues"
+  },
+  "homepage": "https://github.com/kydycode/todoist-mcp-server-ext#readme",
+  "dependencies": {
+    "@doist/todoist-api-typescript": "^3.0.3",
+    "@modelcontextprotocol/sdk": "0.5.0",
+    "zod": "^3.22.0"
+  },
+  "devDependencies": {
+    "@types/node": "^22.10.1",
+    "shx": "^0.3.4",
+    "typescript": "^5.7.2"
+  }
+}