@iflow-mcp/omnifocus-mcp 1.2.3

package/README.md

@@ -0,0 +1,250 @@
+# OmniFocus MCP Server
+
+A Model Context Protocol (MCP) server that integrates with OmniFocus to enable Claude (or other MCP-compatible clients) to interact with your tasks and projects.
+
+![OmniFocus MCP](assets/omnifocus-mcp-logo.png)
+
+## Overview
+
+This MCP server creates a bridge between AI assistants (like Claude) and your OmniFocus task management system. It gives AI models the ability to view, create, edit, and remove tasks and projects in your OmniFocus database through natural language conversations.
+Some ways you could use it: 
+
+- Translate the PDF of a syllabus into a fully specificed project with tasks, tags, defer dates, and due dates.
+- Turn a meeting transcript into a list of actions
+- Create visualizations of your tasks, projects, and tags
+- Process multiple tasks or projects in a single operation
+- Bulk manage your OmniFocus items efficiently
+
+**Known Issues**
+- Dump_database tool currently fails for very large omnifocus databases. 
+
+## Roadmap
+- ~~Enable the client to interact with perspectives~~ ✅ (Added list_perspectives and get_perspective_view)
+- Benefit from MCP `resource` and `prompt` features
+- Add support for the new `planned` date type in Omnifocus 4.7
+- Support manipulating notifications for projects and tasks
+
+
+## 🚀 Quick Start
+
+### Prerequisites
+- macOS with OmniFocus installed
+
+### Connecting to Claude
+
+1. In Claude Desktop, add this MCP server to your configuration file at:
+```
+~/Library/Application Support/Claude/claude_desktop_config.json
+```
+
+2. Add the following configuration:
+```json
+{
+  "mcpServers": {
+    "omnifocus": {
+      "command": "npx",
+      "args": ["-y", "omnifocus-mcp"]
+    }
+  }
+}
+```
+
+3. Restart Claude Desktop
+
+## Use Cases
+
+### Efficient Task Queries
+Use the new `query_omnifocus` tool for fast, targeted searches:
+> "Show me tasks due today"
+> "Get all flagged items in my Work project"  
+> "Count how many tasks are in each project"
+
+### Reorganize your projects, tasks, and tags
+> "I want every task to have an energy level tag. Show me a list of all the tasks that don't have an energy level tag and your suggestions for what tag to add. I'll make any changes I think are appropriate. Then make the changes in OmniFocus."
+
+### Add tasks from any conversation
+
+> "Ok, thanks for the detailed explanation of why the rule of law is important. Add a recurring task to my activism project that reminds me to call my representative weekly. Include a summary of this conversation in the notes field."
+
+### Quick, Virtual Perspectives
+
+Get a summary of your current tasks and manage them conversationally:
+
+> "Show me all my flagged tasks due this week"
+
+Or create custom views:
+
+> "What are my next actions in the Work folder?"
+
+### Work with OmniFocus Perspectives
+
+List and view your perspectives:
+
+> "What perspectives do I have available?"
+> "Show me what's in my Inbox perspective"
+> "Get the flagged items from my current perspective" 
+
+### Process Transcripts or PDFs
+
+Extract action items from meeting transcripts, academic research articles, or notes:
+
+> "I'm pasting in the transcript from today's meeting. Please analyze it and create tasks in OmniFocus for any action items assigned to me. Put them in my 'Product Development' project."
+
+
+## 🔧 Available Tools
+
+The server currently provides these tools:
+
+### `query_omnifocus` ⭐ NEW
+Efficiently query your OmniFocus database with powerful filters. Get specific tasks, projects, or folders without loading the entire database.
+
+Key Features:
+- **Filter by multiple criteria**: project, tags, status, due dates, flags, and more
+- **Request specific fields**: Reduce response size by only getting the data you need
+- **Sort and limit results**: Control the output format
+- **Much faster than dump_database** for targeted queries
+
+Common Uses:
+```
+"Show me all flagged tasks due this week"
+"Get next actions from my Work project"
+"Count tasks in each project" (use with summary: true)
+"Find all tasks deferred until tomorrow"
+```
+
+Parameters:
+- `entity`: Type to query ('tasks', 'projects', or 'folders')
+- `filters`: (Optional) Narrow results by project, tags, status, dates, etc.
+- `fields`: (Optional) Specific fields to return (id, name, dueDate, etc.)
+- `limit`: (Optional) Maximum items to return
+- `sortBy`: (Optional) Field to sort by
+- `includeCompleted`: (Optional) Include completed items (default: false)
+- `summary`: (Optional) Return only count instead of full details
+
+### `dump_database`
+Gets the complete current state of your OmniFocus database. Best for comprehensive analysis or when you need everything.
+
+Parameters:
+- `hideCompleted`: (Optional) Hide completed/dropped tasks (default: true)
+- `hideRecurringDuplicates`: (Optional) Hide duplicate recurring tasks (default: true)
+
+### `add_omnifocus_task`
+Add a new task to OmniFocus.
+
+Parameters:
+- `name`: The name of the task
+- `projectName`: (Optional) The name of the project to add the task to
+- `note`: (Optional) Additional notes for the task
+- `dueDate`: (Optional) The due date of the task in ISO format
+- `deferDate`: (Optional) The defer date of the task in ISO format
+- `flagged`: (Optional) Whether the task is flagged or not
+- `estimatedMinutes`: (Optional) Estimated time to complete the task
+- `tags`: (Optional) Tags to assign to the task
+ - `parentTaskId`: (Optional) Create under an existing parent task by ID
+ - `parentTaskName`: (Optional) Create under first matching parent task by name (fallback)
+
+### `add_project`
+Add a new project to OmniFocus.
+
+Parameters:
+- `name`: The name of the project
+- `folderName`: (Optional) The name of the folder to add the project to
+- `note`: (Optional) Additional notes for the project
+- `dueDate`: (Optional) The due date of the project in ISO format
+- `deferDate`: (Optional) The defer date of the project in ISO format
+- `flagged`: (Optional) Whether the project is flagged or not
+- `estimatedMinutes`: (Optional) Estimated time to complete the project
+- `tags`: (Optional) Tags to assign to the project
+- `sequential`: (Optional) Whether tasks in the project should be sequential
+
+### `remove_item`
+Remove a task or project from OmniFocus.
+
+Parameters:
+- `id`: (Optional) The ID of the task or project to remove
+- `name`: (Optional) The name of the task or project to remove
+- `itemType`: The type of item to remove ('task' or 'project')
+
+### `edit_item`
+Edit a task or project in OmniFocus.
+
+Parameters:
+- `id`: (Optional) The ID of the task or project to edit
+- `name`: (Optional) The name of the task or project to edit
+- `itemType`: The type of item to edit ('task' or 'project')
+- Various parameters for editing properties
+
+### `batch_add_items`
+Add multiple tasks or projects to OmniFocus in a single operation.
+
+Parameters:
+- `items`: Array of items to add, where each item can be:
+  - `type`: The type of item ('task' or 'project')
+  - `name`: The name of the item
+  - `note`: (Optional) Additional notes
+  - `dueDate`: (Optional) Due date in ISO format
+  - `deferDate`: (Optional) Defer date in ISO format
+  - `flagged`: (Optional) Whether the item is flagged
+  - `estimatedMinutes`: (Optional) Estimated completion time
+  - `tags`: (Optional) Array of tags
+  - `projectName`: (Optional) For tasks: the project to add to
+  - `folderName`: (Optional) For projects: the folder to add to
+  - `sequential`: (Optional) For projects: whether tasks are sequential
+  - `parentTaskId`: (Optional, tasks): Parent task by ID
+  - `parentTaskName`: (Optional, tasks): Parent task by name (fallback)
+  - `tempId`: (Optional, tasks): Temporary ID for within-batch references
+  - `parentTempId`: (Optional, tasks): Reference to another item's `tempId` to establish hierarchy
+  - `hierarchyLevel`: (Optional, tasks): Ordering hint (0 for root, 1 for child, ...)
+
+Examples:
+```
+{
+  "items": [
+    { "type": "task", "name": "Parent", "projectName": "My Project", "tempId": "p1" },
+    { "type": "task", "name": "Child A", "parentTempId": "p1" },
+    { "type": "task", "name": "Child B", "parentTempId": "p1" }
+  ]
+}
+```
+
+### `batch_remove_items`
+Remove multiple tasks or projects from OmniFocus in a single operation.
+
+Parameters:
+- `items`: Array of items to remove, where each item can be:
+  - `id`: (Optional) The ID of the item to remove
+  - `name`: (Optional) The name of the item to remove
+  - `itemType`: The type of item ('task' or 'project')
+
+### `list_perspectives` ⭐ NEW
+List all available perspectives in OmniFocus, including built-in and custom perspectives.
+
+Parameters:
+- `includeBuiltIn`: (Optional) Include built-in perspectives like Inbox, Projects, Tags (default: true)
+- `includeCustom`: (Optional) Include custom perspectives (Pro feature) (default: true)
+
+Returns:
+- List of perspectives with their names, types (builtin/custom), and whether they can be modified
+
+### `get_perspective_view` ⭐ NEW
+Get the items visible in the current OmniFocus perspective. Shows what tasks and projects are displayed.
+
+Parameters:
+- `perspectiveName`: Name of the perspective to view (e.g., 'Inbox', 'Projects', 'Flagged')
+- `limit`: (Optional) Maximum number of items to return (default: 100)
+- `includeMetadata`: (Optional) Include additional metadata like tags and dates (default: true)
+- `fields`: (Optional) Specific fields to include in the response
+
+Note: This tool returns the content of the current perspective window. Due to OmniJS limitations, it cannot programmatically switch perspectives.
+
+## Development
+
+Documentation to follow.
+
+## How It Works
+
+This server uses AppleScript to communicate with OmniFocus, allowing it to interact with the application's native functionality. The server is built using the Model Context Protocol SDK, which provides a standardized way for AI models to interact with external tools and systems.
+
+## 🤝 Contributing
+
+Contributions are welcome! Please feel free to submit a Pull Request.

package/cli.cjs

@@ -0,0 +1,9 @@
+#!/usr/bin/env node
+// cli.cjs
+const path = require('path');
+const childProcess = require('child_process');
+
+const serverPath = path.join(__dirname, 'dist', 'server.js');
+childProcess.spawn('node', ['--experimental-modules', serverPath], { 
+    stdio: 'inherit'
+});

package/dist/omnifocustypes.js

@@ -0,0 +1,48 @@
+// Core enums
+export var Task;
+(function (Task) {
+    let Status;
+    (function (Status) {
+        Status[Status["Available"] = 0] = "Available";
+        Status[Status["Blocked"] = 1] = "Blocked";
+        Status[Status["Completed"] = 2] = "Completed";
+        Status[Status["Dropped"] = 3] = "Dropped";
+        Status[Status["DueSoon"] = 4] = "DueSoon";
+        Status[Status["Next"] = 5] = "Next";
+        Status[Status["Overdue"] = 6] = "Overdue";
+    })(Status = Task.Status || (Task.Status = {}));
+    let RepetitionMethod;
+    (function (RepetitionMethod) {
+        RepetitionMethod[RepetitionMethod["DeferUntilDate"] = 0] = "DeferUntilDate";
+        RepetitionMethod[RepetitionMethod["DueDate"] = 1] = "DueDate";
+        RepetitionMethod[RepetitionMethod["Fixed"] = 2] = "Fixed";
+        RepetitionMethod[RepetitionMethod["None"] = 3] = "None";
+    })(RepetitionMethod = Task.RepetitionMethod || (Task.RepetitionMethod = {}));
+})(Task || (Task = {}));
+export var Project;
+(function (Project) {
+    let Status;
+    (function (Status) {
+        Status[Status["Active"] = 0] = "Active";
+        Status[Status["Done"] = 1] = "Done";
+        Status[Status["Dropped"] = 2] = "Dropped";
+        Status[Status["OnHold"] = 3] = "OnHold";
+    })(Status = Project.Status || (Project.Status = {}));
+})(Project || (Project = {}));
+export var Folder;
+(function (Folder) {
+    let Status;
+    (function (Status) {
+        Status[Status["Active"] = 0] = "Active";
+        Status[Status["Dropped"] = 1] = "Dropped";
+    })(Status = Folder.Status || (Folder.Status = {}));
+})(Folder || (Folder = {}));
+export var Tag;
+(function (Tag) {
+    let Status;
+    (function (Status) {
+        Status[Status["Active"] = 0] = "Active";
+        Status[Status["Dropped"] = 1] = "Dropped";
+        Status[Status["OnHold"] = 2] = "OnHold";
+    })(Status = Tag.Status || (Tag.Status = {}));
+})(Tag || (Tag = {}));

package/dist/server.js

@@ -0,0 +1,44 @@
+#!/usr/bin/env node
+import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
+// Import tool definitions
+import * as dumpDatabaseTool from './tools/definitions/dumpDatabase.js';
+import * as addOmniFocusTaskTool from './tools/definitions/addOmniFocusTask.js';
+import * as addProjectTool from './tools/definitions/addProject.js';
+import * as removeItemTool from './tools/definitions/removeItem.js';
+import * as editItemTool from './tools/definitions/editItem.js';
+import * as batchAddItemsTool from './tools/definitions/batchAddItems.js';
+import * as batchRemoveItemsTool from './tools/definitions/batchRemoveItems.js';
+import * as queryOmniFocusTool from './tools/definitions/queryOmnifocus.js';
+import * as listPerspectivesTool from './tools/definitions/listPerspectives.js';
+import * as getPerspectiveViewTool from './tools/definitions/getPerspectiveView.js';
+// Create an MCP server
+const server = new McpServer({
+    name: "OmniFocus MCP",
+    version: "1.0.0"
+});
+// Register tools
+server.tool("dump_database", "Gets the current state of your OmniFocus database", dumpDatabaseTool.schema.shape, dumpDatabaseTool.handler);
+server.tool("add_omnifocus_task", "Add a new task to OmniFocus", addOmniFocusTaskTool.schema.shape, addOmniFocusTaskTool.handler);
+server.tool("add_project", "Add a new project to OmniFocus", addProjectTool.schema.shape, addProjectTool.handler);
+server.tool("remove_item", "Remove a task or project from OmniFocus", removeItemTool.schema.shape, removeItemTool.handler);
+server.tool("edit_item", "Edit a task or project in OmniFocus", editItemTool.schema.shape, editItemTool.handler);
+server.tool("batch_add_items", "Add multiple tasks or projects to OmniFocus in a single operation", batchAddItemsTool.schema.shape, batchAddItemsTool.handler);
+server.tool("batch_remove_items", "Remove multiple tasks or projects from OmniFocus in a single operation", batchRemoveItemsTool.schema.shape, batchRemoveItemsTool.handler);
+server.tool("query_omnifocus", "Efficiently query OmniFocus database with powerful filters. Get specific tasks, projects, or folders without loading the entire database. Supports filtering by project, tags, status, due dates, and more. Much faster than dump_database for targeted queries.", queryOmniFocusTool.schema.shape, queryOmniFocusTool.handler);
+server.tool("list_perspectives", "List all available perspectives in OmniFocus, including built-in perspectives (Inbox, Projects, Tags, etc.) and custom perspectives (Pro feature)", listPerspectivesTool.schema.shape, listPerspectivesTool.handler);
+server.tool("get_perspective_view", "Get the items visible in a specific OmniFocus perspective. Shows what tasks and projects are displayed when viewing that perspective", getPerspectiveViewTool.schema.shape, getPerspectiveViewTool.handler);
+// Start the MCP server
+const transport = new StdioServerTransport();
+// Use await with server.connect to ensure proper connection
+(async function () {
+    try {
+        console.error("Starting MCP server...");
+        await server.connect(transport);
+        console.error("MCP Server connected and ready to accept commands from Claude");
+    }
+    catch (err) {
+        console.error(`Failed to start MCP server: ${err}`);
+    }
+})();
+// For a cleaner shutdown if the process is terminated

package/dist/tools/definitions/addOmniFocusTask.js

@@ -0,0 +1,76 @@
+import { z } from 'zod';
+import { addOmniFocusTask } from '../primitives/addOmniFocusTask.js';
+export const schema = z.object({
+    name: z.string().describe("The name of the task"),
+    note: z.string().optional().describe("Additional notes for the task"),
+    dueDate: z.string().optional().describe("The due date of the task in ISO format (YYYY-MM-DD or full ISO date)"),
+    deferDate: z.string().optional().describe("The defer date of the task in ISO format (YYYY-MM-DD or full ISO date)"),
+    flagged: z.boolean().optional().describe("Whether the task is flagged or not"),
+    estimatedMinutes: z.number().optional().describe("Estimated time to complete the task, in minutes"),
+    tags: z.array(z.string()).optional().describe("Tags to assign to the task"),
+    projectName: z.string().optional().describe("The name of the project to add the task to (will add to inbox if not specified)"),
+    // Hierarchy support
+    parentTaskId: z.string().optional().describe("ID of the parent task (preferred for accuracy)"),
+    parentTaskName: z.string().optional().describe("Name of the parent task (used if ID not provided; matched within project or globally if no project)"),
+    hierarchyLevel: z.number().int().min(0).optional().describe("Explicit level indicator for ordering in batch workflows (0=root) - ignored in single add")
+});
+export async function handler(args, extra) {
+    try {
+        // Call the addOmniFocusTask function 
+        const result = await addOmniFocusTask(args);
+        console.error('[add_omnifocus_task] args:', JSON.stringify(args));
+        console.error('[add_omnifocus_task] result:', JSON.stringify(result));
+        if (result.success) {
+            // Determine actual placement
+            const placement = result.placement;
+            let locationText = '';
+            if (placement === 'parent') {
+                locationText = 'under the parent task';
+            }
+            else if (placement === 'project') {
+                locationText = args.projectName ? `in project "${args.projectName}"` : 'in a project';
+            }
+            else {
+                locationText = 'in your inbox';
+            }
+            const tagText = args.tags && args.tags.length > 0
+                ? ` with tags: ${args.tags.join(', ')}`
+                : '';
+            const dueDateText = args.dueDate
+                ? ` due on ${new Date(args.dueDate).toLocaleDateString()}`
+                : '';
+            // Warning if parent requested but not used
+            let placementWarning = '';
+            if ((args.parentTaskId || args.parentTaskName) && placement && placement !== 'parent') {
+                placementWarning = `\n⚠️ Parent not found; task created ${placement === 'project' ? 'in project' : 'in inbox'}.`;
+            }
+            return {
+                content: [{
+                        type: "text",
+                        text: `✅ Task "${args.name}" created successfully ${locationText}${dueDateText}${tagText}.${placementWarning}`
+                    }]
+            };
+        }
+        else {
+            // Task creation failed
+            return {
+                content: [{
+                        type: "text",
+                        text: `Failed to create task: ${result.error}`
+                    }],
+                isError: true
+            };
+        }
+    }
+    catch (err) {
+        const error = err;
+        console.error(`Tool execution error: ${error.message}`);
+        return {
+            content: [{
+                    type: "text",
+                    text: `Error creating task: ${error.message}`
+                }],
+            isError: true
+        };
+    }
+}

package/dist/tools/definitions/addProject.js

@@ -0,0 +1,61 @@
+import { z } from 'zod';
+import { addProject } from '../primitives/addProject.js';
+export const schema = z.object({
+    name: z.string().describe("The name of the project"),
+    note: z.string().optional().describe("Additional notes for the project"),
+    dueDate: z.string().optional().describe("The due date of the project in ISO format (YYYY-MM-DD or full ISO date)"),
+    deferDate: z.string().optional().describe("The defer date of the project in ISO format (YYYY-MM-DD or full ISO date)"),
+    flagged: z.boolean().optional().describe("Whether the project is flagged or not"),
+    estimatedMinutes: z.number().optional().describe("Estimated time to complete the project, in minutes"),
+    tags: z.array(z.string()).optional().describe("Tags to assign to the project"),
+    folderName: z.string().optional().describe("The name of the folder to add the project to (will add to root if not specified)"),
+    sequential: z.boolean().optional().describe("Whether tasks in the project should be sequential (default: false)")
+});
+export async function handler(args, extra) {
+    try {
+        // Call the addProject function 
+        const result = await addProject(args);
+        if (result.success) {
+            // Project was added successfully
+            let locationText = args.folderName
+                ? `in folder "${args.folderName}"`
+                : "at the root level";
+            let tagText = args.tags && args.tags.length > 0
+                ? ` with tags: ${args.tags.join(', ')}`
+                : "";
+            let dueDateText = args.dueDate
+                ? ` due on ${new Date(args.dueDate).toLocaleDateString()}`
+                : "";
+            let sequentialText = args.sequential
+                ? " (sequential)"
+                : " (parallel)";
+            return {
+                content: [{
+                        type: "text",
+                        text: `✅ Project "${args.name}" created successfully ${locationText}${dueDateText}${tagText}${sequentialText}.`
+                    }]
+            };
+        }
+        else {
+            // Project creation failed
+            return {
+                content: [{
+                        type: "text",
+                        text: `Failed to create project: ${result.error}`
+                    }],
+                isError: true
+            };
+        }
+    }
+    catch (err) {
+        const error = err;
+        console.error(`Tool execution error: ${error.message}`);
+        return {
+            content: [{
+                    type: "text",
+                    text: `Error creating project: ${error.message}`
+                }],
+            isError: true
+        };
+    }
+}

package/dist/tools/definitions/batchAddItems.js

@@ -0,0 +1,89 @@
+import { z } from 'zod';
+import { batchAddItems } from '../primitives/batchAddItems.js';
+export const schema = z.object({
+    items: z.array(z.object({
+        type: z.enum(['task', 'project']).describe("Type of item to add ('task' or 'project')"),
+        name: z.string().describe("The name of the item"),
+        note: z.string().optional().describe("Additional notes for the item"),
+        dueDate: z.string().optional().describe("The due date in ISO format (YYYY-MM-DD or full ISO date)"),
+        deferDate: z.string().optional().describe("The defer date in ISO format (YYYY-MM-DD or full ISO date)"),
+        flagged: z.boolean().optional().describe("Whether the item is flagged or not"),
+        estimatedMinutes: z.number().optional().describe("Estimated time to complete the item, in minutes"),
+        tags: z.array(z.string()).optional().describe("Tags to assign to the item"),
+        // Task-specific properties
+        projectName: z.string().optional().describe("For tasks: The name of the project to add the task to"),
+        parentTaskId: z.string().optional().describe("For tasks: ID of the parent task"),
+        parentTaskName: z.string().optional().describe("For tasks: Name of the parent task (scoped to project when provided)"),
+        tempId: z.string().optional().describe("For tasks: Temporary ID for within-batch references"),
+        parentTempId: z.string().optional().describe("For tasks: Reference to parent's tempId within the batch"),
+        hierarchyLevel: z.number().int().min(0).optional().describe("Optional ordering hint (0=root, 1=child, ...)"),
+        // Project-specific properties
+        folderName: z.string().optional().describe("For projects: The name of the folder to add the project to"),
+        sequential: z.boolean().optional().describe("For projects: Whether tasks in the project should be sequential")
+    })).describe("Array of items (tasks or projects) to add"),
+    createSequentially: z.boolean().optional().describe("Process parents before children; when false, best-effort order will still try to resolve parents first")
+});
+export async function handler(args, extra) {
+    try {
+        // Call the batchAddItems function
+        const result = await batchAddItems(args.items);
+        if (result.success) {
+            const successCount = result.results.filter(r => r.success).length;
+            const failureCount = result.results.filter(r => !r.success).length;
+            let message = `✅ Successfully added ${successCount} items.`;
+            if (failureCount > 0) {
+                message += ` ⚠️ Failed to add ${failureCount} items.`;
+            }
+            // Include details about added items
+            const details = result.results.map((item, index) => {
+                if (item.success) {
+                    const itemType = args.items[index].type;
+                    const itemName = args.items[index].name;
+                    return `- ✅ ${itemType}: "${itemName}"`;
+                }
+                else {
+                    const itemType = args.items[index].type;
+                    const itemName = args.items[index].name;
+                    return `- ❌ ${itemType}: "${itemName}" - Error: ${item.error}`;
+                }
+            }).join('\n');
+            return {
+                content: [{
+                        type: "text",
+                        text: `${message}\n\n${details}`
+                    }]
+            };
+        }
+        else {
+            console.error('[batch_add_items] failure result:', JSON.stringify(result));
+            // Batch operation failed completely or no items succeeded.
+            const failureDetails = (result.results && result.results.length > 0)
+                ? result.results.map((r, index) => {
+                    const itemType = args.items[index].type;
+                    const itemName = args.items[index].name;
+                    return r.success
+                        ? `- ✅ ${itemType}: \"${itemName}\"`
+                        : `- ❌ ${itemType}: \"${itemName}\" - Error: ${r?.error || 'Unknown error'}`;
+                }).join('\\n')
+                : `No items processed. ${result.error || ''}`;
+            return {
+                content: [{
+                        type: "text",
+                        text: `Failed to process batch operation.\\n\\n${failureDetails}`
+                    }],
+                isError: true
+            };
+        }
+    }
+    catch (err) {
+        const error = err;
+        console.error(`Tool execution error: ${error.message}`);
+        return {
+            content: [{
+                    type: "text",
+                    text: `Error processing batch operation: ${error.message}`
+                }],
+            isError: true
+        };
+    }
+}

package/dist/tools/definitions/batchRemoveItems.js

@@ -0,0 +1,74 @@
+import { z } from 'zod';
+import { batchRemoveItems } from '../primitives/batchRemoveItems.js';
+export const schema = z.object({
+    items: z.array(z.object({
+        id: z.string().optional().describe("The ID of the task or project to remove"),
+        name: z.string().optional().describe("The name of the task or project to remove (as fallback if ID not provided)"),
+        itemType: z.enum(['task', 'project']).describe("Type of item to remove ('task' or 'project')")
+    })).describe("Array of items (tasks or projects) to remove")
+});
+export async function handler(args, extra) {
+    try {
+        // Validate that each item has at least an ID or name
+        for (const item of args.items) {
+            if (!item.id && !item.name) {
+                return {
+                    content: [{
+                            type: "text",
+                            text: "Each item must have either id or name provided to remove it."
+                        }],
+                    isError: true
+                };
+            }
+        }
+        // Call the batchRemoveItems function
+        const result = await batchRemoveItems(args.items);
+        if (result.success) {
+            const successCount = result.results.filter(r => r.success).length;
+            const failureCount = result.results.filter(r => !r.success).length;
+            let message = `✅ Successfully removed ${successCount} items.`;
+            if (failureCount > 0) {
+                message += ` ⚠️ Failed to remove ${failureCount} items.`;
+            }
+            // Include details about removed items
+            const details = result.results.map((item, index) => {
+                if (item.success) {
+                    const itemType = args.items[index].itemType;
+                    return `- ✅ ${itemType}: "${item.name}"`;
+                }
+                else {
+                    const itemType = args.items[index].itemType;
+                    const identifier = args.items[index].id || args.items[index].name;
+                    return `- ❌ ${itemType}: ${identifier} - Error: ${item.error}`;
+                }
+            }).join('\n');
+            return {
+                content: [{
+                        type: "text",
+                        text: `${message}\n\n${details}`
+                    }]
+            };
+        }
+        else {
+            // Batch operation failed completely
+            return {
+                content: [{
+                        type: "text",
+                        text: `Failed to process batch removal: ${result.error}`
+                    }],
+                isError: true
+            };
+        }
+    }
+    catch (err) {
+        const error = err;
+        console.error(`Tool execution error: ${error.message}`);
+        return {
+            content: [{
+                    type: "text",
+                    text: `Error processing batch removal: ${error.message}`
+                }],
+            isError: true
+        };
+    }
+}