omnifocus-mcp-enhanced 1.1.0

package/dist/tools/definitions/addSubtask.js

@@ -0,0 +1,66 @@
+import { z } from 'zod';
+import { addSubtask } from '../primitives/addSubtask.js';
+export const schema = z.object({
+    name: z.string().describe("The name of the subtask"),
+    parentTaskId: z.string().optional().describe("The ID of the parent task"),
+    parentTaskName: z.string().optional().describe("The name of the parent task (alternative to parentTaskId)"),
+    note: z.string().optional().describe("Additional notes for the subtask"),
+    dueDate: z.string().optional().describe("The due date of the subtask in ISO format (YYYY-MM-DD or full ISO date)"),
+    deferDate: z.string().optional().describe("The defer date of the subtask in ISO format (YYYY-MM-DD or full ISO date)"),
+    flagged: z.boolean().optional().describe("Whether the subtask is flagged or not"),
+    estimatedMinutes: z.number().optional().describe("Estimated time to complete the subtask, in minutes"),
+    tags: z.array(z.string()).optional().describe("Tags to assign to the subtask")
+});
+export async function handler(args, extra) {
+    try {
+        // Validate that either parentTaskId or parentTaskName is provided
+        if (!args.parentTaskId && !args.parentTaskName) {
+            return {
+                content: [{
+                        type: "text",
+                        text: "Error: Either parentTaskId or parentTaskName must be provided for subtask creation."
+                    }],
+                isError: true
+            };
+        }
+        // Call the addSubtask function 
+        const result = await addSubtask(args);
+        if (result.success) {
+            // Subtask was added successfully
+            const parentRef = args.parentTaskId || args.parentTaskName;
+            let tagText = args.tags && args.tags.length > 0
+                ? ` with tags: ${args.tags.join(', ')}`
+                : "";
+            let dueDateText = args.dueDate
+                ? ` due on ${new Date(args.dueDate).toLocaleDateString()}`
+                : "";
+            return {
+                content: [{
+                        type: "text",
+                        text: `✅ Subtask "${args.name}" created successfully under parent task "${parentRef}"${dueDateText}${tagText}.`
+                    }]
+            };
+        }
+        else {
+            // Subtask creation failed
+            return {
+                content: [{
+                        type: "text",
+                        text: `Failed to create subtask: ${result.error}`
+                    }],
+                isError: true
+            };
+        }
+    }
+    catch (err) {
+        const error = err;
+        console.error(`Tool execution error: ${error.message}`);
+        return {
+            content: [{
+                    type: "text",
+                    text: `Error creating subtask: ${error.message}`
+                }],
+            isError: true
+        };
+    }
+}

package/dist/tools/definitions/batchAddItems.js

@@ -0,0 +1,75 @@
+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: The ID of the parent task to create this task as a subtask"),
+        parentTaskName: z.string().optional().describe("For tasks: The name of the parent task to create this task as a subtask"),
+        // 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")
+});
+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 {
+            // Batch operation failed completely
+            return {
+                content: [{
+                        type: "text",
+                        text: `Failed to process batch operation: ${result.error}`
+                    }],
+                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
+        };
+    }
+}

package/dist/tools/definitions/dumpDatabase.js

@@ -0,0 +1,249 @@
+import { z } from 'zod';
+import { dumpDatabase } from '../dumpDatabase.js';
+export const schema = z.object({
+    hideCompleted: z.boolean().optional().describe("Set to false to show completed and dropped tasks (default: true)"),
+    hideRecurringDuplicates: z.boolean().optional().describe("Set to true to hide duplicate instances of recurring tasks (default: true)")
+});
+export async function handler(args, extra) {
+    try {
+        // Get raw database
+        const database = await dumpDatabase();
+        // Format as compact report
+        const formattedReport = formatCompactReport(database, {
+            hideCompleted: args.hideCompleted !== false, // Default to true
+            hideRecurringDuplicates: args.hideRecurringDuplicates !== false // Default to true
+        });
+        return {
+            content: [{
+                    type: "text",
+                    text: formattedReport
+                }]
+        };
+    }
+    catch (err) {
+        return {
+            content: [{
+                    type: "text",
+                    text: `Error generating report. Please ensure OmniFocus is running and try again.`
+                }],
+            isError: true
+        };
+    }
+}
+// Function to format date in compact format (M/D)
+function formatCompactDate(isoDate) {
+    if (!isoDate)
+        return '';
+    const date = new Date(isoDate);
+    return `${date.getMonth() + 1}/${date.getDate()}`;
+}
+// Function to format the database in the compact report format
+function formatCompactReport(database, options) {
+    const { hideCompleted, hideRecurringDuplicates } = options;
+    // Get current date for the header
+    const today = new Date();
+    const dateStr = today.toISOString().split('T')[0];
+    let output = `# OMNIFOCUS [${dateStr}]\n\n`;
+    // Add legend
+    output += `FORMAT LEGEND:
+F: Folder | P: Project | •: Task | 🚩: Flagged
+Dates: [M/D] | Duration: (30m) or (2h) | Tags: <tag1,tag2>
+Status: #next #avail #block #due #over #compl #drop\n\n`;
+    // Map of folder IDs to folder objects for quick lookup
+    const folderMap = new Map();
+    Object.values(database.folders).forEach((folder) => {
+        folderMap.set(folder.id, folder);
+    });
+    // Get all tag names to compute minimum unique prefixes
+    const allTagNames = Object.values(database.tags).map((tag) => tag.name);
+    const tagPrefixMap = computeMinimumUniquePrefixes(allTagNames);
+    // Function to get folder hierarchy path 
+    function getFolderPath(folderId) {
+        const path = [];
+        let currentId = folderId;
+        while (currentId) {
+            const folder = folderMap.get(currentId);
+            if (!folder)
+                break;
+            path.unshift(folder.name);
+            currentId = folder.parentFolderID;
+        }
+        return path;
+    }
+    // Get root folders (no parent)
+    const rootFolders = Object.values(database.folders).filter((folder) => !folder.parentFolderID);
+    // Process folders recursively
+    function processFolder(folder, level) {
+        const indent = '   '.repeat(level);
+        let folderOutput = `${indent}F: ${folder.name}\n`;
+        // Process subfolders
+        if (folder.subfolders && folder.subfolders.length > 0) {
+            for (const subfolderId of folder.subfolders) {
+                const subfolder = database.folders[subfolderId];
+                if (subfolder) {
+                    folderOutput += `${processFolder(subfolder, level + 1)}`;
+                }
+            }
+        }
+        // Process projects in this folder
+        if (folder.projects && folder.projects.length > 0) {
+            for (const projectId of folder.projects) {
+                const project = database.projects[projectId];
+                if (project) {
+                    folderOutput += processProject(project, level + 1);
+                }
+            }
+        }
+        return folderOutput;
+    }
+    // Process a project
+    function processProject(project, level) {
+        const indent = '   '.repeat(level);
+        // Skip if it's completed or dropped and we're hiding completed items
+        if (hideCompleted && (project.status === 'Done' || project.status === 'Dropped')) {
+            return '';
+        }
+        // Format project status info
+        let statusInfo = '';
+        if (project.status === 'OnHold') {
+            statusInfo = ' [OnHold]';
+        }
+        else if (project.status === 'Dropped') {
+            statusInfo = ' [Dropped]';
+        }
+        // Add due date if present
+        if (project.dueDate) {
+            const dueDateStr = formatCompactDate(project.dueDate);
+            statusInfo += statusInfo ? ` [DUE:${dueDateStr}]` : ` [DUE:${dueDateStr}]`;
+        }
+        // Add flag if present
+        const flaggedSymbol = project.flagged ? ' 🚩' : '';
+        let projectOutput = `${indent}P: ${project.name}${flaggedSymbol}${statusInfo}\n`;
+        // Process tasks in this project
+        const projectTasks = database.tasks.filter((task) => task.projectId === project.id && !task.parentId);
+        if (projectTasks.length > 0) {
+            for (const task of projectTasks) {
+                projectOutput += processTask(task, level + 1);
+            }
+        }
+        return projectOutput;
+    }
+    // Process a task
+    function processTask(task, level) {
+        const indent = '   '.repeat(level);
+        // Skip if it's completed or dropped and we're hiding completed items
+        if (hideCompleted && (task.completed || task.taskStatus === 'Completed' || task.taskStatus === 'Dropped')) {
+            return '';
+        }
+        // Flag symbol
+        const flagSymbol = task.flagged ? '🚩 ' : '';
+        // Format dates
+        let dateInfo = '';
+        if (task.dueDate) {
+            const dueDateStr = formatCompactDate(task.dueDate);
+            dateInfo += ` [DUE:${dueDateStr}]`;
+        }
+        if (task.deferDate) {
+            const deferDateStr = formatCompactDate(task.deferDate);
+            dateInfo += ` [defer:${deferDateStr}]`;
+        }
+        // Format duration
+        let durationStr = '';
+        if (task.estimatedMinutes) {
+            // Convert to hours if >= 60 minutes
+            if (task.estimatedMinutes >= 60) {
+                const hours = Math.floor(task.estimatedMinutes / 60);
+                durationStr = ` (${hours}h)`;
+            }
+            else {
+                durationStr = ` (${task.estimatedMinutes}m)`;
+            }
+        }
+        // Format tags
+        let tagsStr = '';
+        if (task.tagNames && task.tagNames.length > 0) {
+            // Use minimum unique prefixes for tag names
+            const abbreviatedTags = task.tagNames.map((tag) => {
+                return tagPrefixMap.get(tag) || tag;
+            });
+            tagsStr = ` <${abbreviatedTags.join(',')}>`;
+        }
+        // Format status
+        let statusStr = '';
+        switch (task.taskStatus) {
+            case 'Next':
+                statusStr = ' #next';
+                break;
+            case 'Available':
+                statusStr = ' #avail';
+                break;
+            case 'Blocked':
+                statusStr = ' #block';
+                break;
+            case 'DueSoon':
+                statusStr = ' #due';
+                break;
+            case 'Overdue':
+                statusStr = ' #over';
+                break;
+            case 'Completed':
+                statusStr = ' #compl';
+                break;
+            case 'Dropped':
+                statusStr = ' #drop';
+                break;
+        }
+        let taskOutput = `${indent}• ${flagSymbol}${task.name}${dateInfo}${durationStr}${tagsStr}${statusStr}\n`;
+        // Process subtasks
+        if (task.childIds && task.childIds.length > 0) {
+            const childTasks = database.tasks.filter((t) => task.childIds.includes(t.id));
+            for (const childTask of childTasks) {
+                taskOutput += processTask(childTask, level + 1);
+            }
+        }
+        return taskOutput;
+    }
+    // Process all root folders
+    for (const folder of rootFolders) {
+        output += processFolder(folder, 0);
+    }
+    // Process projects not in any folder (if any)
+    const rootProjects = Object.values(database.projects).filter((project) => !project.folderID);
+    for (const project of rootProjects) {
+        output += processProject(project, 0);
+    }
+    return output;
+}
+// Compute minimum unique prefixes for all tags (minimum 3 characters)
+function computeMinimumUniquePrefixes(tagNames) {
+    const prefixMap = new Map();
+    // For each tag name
+    for (const tagName of tagNames) {
+        // Start with minimum length of 3
+        let prefixLength = 3;
+        let isUnique = false;
+        // Keep increasing prefix length until we find a unique prefix
+        while (!isUnique && prefixLength <= tagName.length) {
+            const prefix = tagName.substring(0, prefixLength);
+            // Check if this prefix uniquely identifies the tag
+            isUnique = tagNames.every(otherTag => {
+                // If it's the same tag, skip comparison
+                if (otherTag === tagName)
+                    return true;
+                // If the other tag starts with the same prefix, it's not unique
+                return !otherTag.startsWith(prefix);
+            });
+            if (isUnique) {
+                prefixMap.set(tagName, prefix);
+            }
+            else {
+                prefixLength++;
+            }
+        }
+        // If we couldn't find a unique prefix, use the full tag name
+        if (!isUnique) {
+            prefixMap.set(tagName, tagName);
+        }
+    }
+    return prefixMap;
+}

package/dist/tools/definitions/editItem.js

@@ -0,0 +1,88 @@
+import { z } from 'zod';
+import { editItem } from '../primitives/editItem.js';
+export const schema = z.object({
+    id: z.string().optional().describe("The ID of the task or project to edit"),
+    name: z.string().optional().describe("The name of the task or project to edit (as fallback if ID not provided)"),
+    itemType: z.enum(['task', 'project']).describe("Type of item to edit ('task' or 'project')"),
+    // Common editable fields
+    newName: z.string().optional().describe("New name for the item"),
+    newNote: z.string().optional().describe("New note for the item"),
+    newDueDate: z.string().optional().describe("New due date in ISO format (YYYY-MM-DD or full ISO date); set to empty string to clear"),
+    newDeferDate: z.string().optional().describe("New defer date in ISO format (YYYY-MM-DD or full ISO date); set to empty string to clear"),
+    newFlagged: z.boolean().optional().describe("Set flagged status (set to false for no flag, true for flag)"),
+    newEstimatedMinutes: z.number().optional().describe("New estimated minutes"),
+    // Task-specific fields
+    newStatus: z.enum(['incomplete', 'completed', 'dropped']).optional().describe("New status for tasks (incomplete, completed, dropped)"),
+    addTags: z.array(z.string()).optional().describe("Tags to add to the task"),
+    removeTags: z.array(z.string()).optional().describe("Tags to remove from the task"),
+    replaceTags: z.array(z.string()).optional().describe("Tags to replace all existing tags with"),
+    // Project-specific fields
+    newSequential: z.boolean().optional().describe("Whether the project should be sequential"),
+    newFolderName: z.string().optional().describe("New folder to move the project to"),
+    newProjectStatus: z.enum(['active', 'completed', 'dropped', 'onHold']).optional().describe("New status for projects")
+});
+export async function handler(args, extra) {
+    try {
+        // Validate that either id or name is provided
+        if (!args.id && !args.name) {
+            return {
+                content: [{
+                        type: "text",
+                        text: "Either id or name must be provided to edit an item."
+                    }],
+                isError: true
+            };
+        }
+        // Call the editItem function 
+        const result = await editItem(args);
+        if (result.success) {
+            // Item was edited successfully
+            const itemTypeLabel = args.itemType === 'task' ? 'Task' : 'Project';
+            let changedText = '';
+            if (result.changedProperties) {
+                changedText = ` (${result.changedProperties})`;
+            }
+            return {
+                content: [{
+                        type: "text",
+                        text: `✅ ${itemTypeLabel} "${result.name}" updated successfully${changedText}.`
+                    }]
+            };
+        }
+        else {
+            // Item editing failed
+            let errorMsg = `Failed to update ${args.itemType}`;
+            if (result.error) {
+                if (result.error.includes("Item not found")) {
+                    errorMsg = `${args.itemType.charAt(0).toUpperCase() + args.itemType.slice(1)} not found`;
+                    if (args.id)
+                        errorMsg += ` with ID "${args.id}"`;
+                    if (args.name)
+                        errorMsg += `${args.id ? ' or' : ' with'} name "${args.name}"`;
+                    errorMsg += '.';
+                }
+                else {
+                    errorMsg += `: ${result.error}`;
+                }
+            }
+            return {
+                content: [{
+                        type: "text",
+                        text: errorMsg
+                    }],
+                isError: true
+            };
+        }
+    }
+    catch (err) {
+        const error = err;
+        console.error(`Tool execution error: ${error.message}`);
+        return {
+            content: [{
+                    type: "text",
+                    text: `Error updating ${args.itemType}: ${error.message}`
+                }],
+            isError: true
+        };
+    }
+}

package/dist/tools/definitions/getTaskById.js

@@ -0,0 +1,66 @@
+import { z } from 'zod';
+import { getTaskById } from '../primitives/getTaskById.js';
+export const schema = z.object({
+    taskId: z.string().optional().describe("The ID of the task to retrieve"),
+    taskName: z.string().optional().describe("The name of the task to retrieve (alternative to taskId)")
+});
+export async function handler(args, extra) {
+    try {
+        // Validate that either taskId or taskName is provided
+        if (!args.taskId && !args.taskName) {
+            return {
+                content: [{
+                        type: "text",
+                        text: "Error: Either taskId or taskName must be provided."
+                    }],
+                isError: true
+            };
+        }
+        // Call the getTaskById function 
+        const result = await getTaskById(args);
+        if (result.success && result.task) {
+            const task = result.task;
+            // Format task information for display
+            let infoText = `📋 **Task Information**\n`;
+            infoText += `• **Name**: ${task.name}\n`;
+            infoText += `• **ID**: ${task.id}\n`;
+            if (task.note) {
+                infoText += `• **Note**: ${task.note}\n`;
+            }
+            if (task.parentId && task.parentName) {
+                infoText += `• **Parent Task**: ${task.parentName} (${task.parentId})\n`;
+            }
+            if (task.projectId && task.projectName) {
+                infoText += `• **Project**: ${task.projectName} (${task.projectId})\n`;
+            }
+            infoText += `• **Has Children**: ${task.hasChildren ? `Yes (${task.childrenCount} subtasks)` : 'No'}\n`;
+            return {
+                content: [{
+                        type: "text",
+                        text: infoText
+                    }]
+            };
+        }
+        else {
+            // Task retrieval failed
+            return {
+                content: [{
+                        type: "text",
+                        text: `Failed to retrieve task: ${result.error}`
+                    }],
+                isError: true
+            };
+        }
+    }
+    catch (err) {
+        const error = err;
+        console.error(`Tool execution error: ${error.message}`);
+        return {
+            content: [{
+                    type: "text",
+                    text: `Error retrieving task: ${error.message}`
+                }],
+            isError: true
+        };
+    }
+}