omnifocus-mcp-enhanced 1.1.0

package/dist/tools/definitions/removeItem.js

@@ -0,0 +1,80 @@
+import { z } from 'zod';
+import { removeItem } from '../primitives/removeItem.js';
+export const schema = 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')")
+});
+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 remove an item."
+                    }],
+                isError: true
+            };
+        }
+        // Validate itemType
+        if (!['task', 'project'].includes(args.itemType)) {
+            return {
+                content: [{
+                        type: "text",
+                        text: `Invalid item type: ${args.itemType}. Must be either 'task' or 'project'.`
+                    }],
+                isError: true
+            };
+        }
+        // Log the remove operation for debugging
+        console.error(`Removing ${args.itemType} with ID: ${args.id || 'not provided'}, Name: ${args.name || 'not provided'}`);
+        // Call the removeItem function 
+        const result = await removeItem(args);
+        if (result.success) {
+            // Item was removed successfully
+            const itemTypeLabel = args.itemType === 'task' ? 'Task' : 'Project';
+            return {
+                content: [{
+                        type: "text",
+                        text: `✅ ${itemTypeLabel} "${result.name}" removed successfully.`
+                    }]
+            };
+        }
+        else {
+            // Item removal failed
+            let errorMsg = `Failed to remove ${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 removing ${args.itemType}: ${error.message}`
+                }],
+            isError: true
+        };
+    }
+}

package/dist/tools/dumpDatabase.js

@@ -0,0 +1,121 @@
+import { executeOmniFocusScript } from '../utils/scriptExecution.js';
+// Main function to dump the database
+export async function dumpDatabase() {
+    try {
+        // Execute the OmniFocus script
+        const data = await executeOmniFocusScript('@omnifocusDump.js');
+        // wait 1 second
+        await new Promise(resolve => setTimeout(resolve, 1000));
+        // Create an empty database if no data returned
+        if (!data) {
+            return {
+                exportDate: new Date().toISOString(),
+                tasks: [],
+                projects: {},
+                folders: {},
+                tags: {}
+            };
+        }
+        // Initialize the database object
+        const database = {
+            exportDate: data.exportDate,
+            tasks: [],
+            projects: {},
+            folders: {},
+            tags: {}
+        };
+        // Process tasks
+        if (data.tasks && Array.isArray(data.tasks)) {
+            // Convert the tasks to our OmnifocusTask format
+            database.tasks = data.tasks.map((task) => {
+                // Get tag names from the tag IDs
+                const tagNames = (task.tags || []).map(tagId => {
+                    return data.tags[tagId]?.name || 'Unknown Tag';
+                });
+                return {
+                    id: String(task.id),
+                    name: String(task.name),
+                    note: String(task.note || ""),
+                    flagged: Boolean(task.flagged),
+                    completed: task.taskStatus === "Completed",
+                    completionDate: null, // Not available in the new format
+                    dropDate: null, // Not available in the new format
+                    taskStatus: String(task.taskStatus),
+                    active: task.taskStatus !== "Completed" && task.taskStatus !== "Dropped",
+                    dueDate: task.dueDate,
+                    deferDate: task.deferDate,
+                    estimatedMinutes: task.estimatedMinutes ? Number(task.estimatedMinutes) : null,
+                    tags: task.tags || [],
+                    tagNames: tagNames,
+                    parentId: task.parentTaskID || null,
+                    containingProjectId: task.projectID || null,
+                    projectId: task.projectID || null,
+                    childIds: task.children || [],
+                    hasChildren: (task.children && task.children.length > 0) || false,
+                    sequential: Boolean(task.sequential),
+                    completedByChildren: Boolean(task.completedByChildren),
+                    isRepeating: false, // Not available in the new format
+                    repetitionMethod: null, // Not available in the new format 
+                    repetitionRule: null, // Not available in the new format
+                    attachments: [], // Default empty array
+                    linkedFileURLs: [], // Default empty array
+                    notifications: [], // Default empty array
+                    shouldUseFloatingTimeZone: false // Default value
+                };
+            });
+        }
+        // Process projects
+        if (data.projects) {
+            for (const [id, project] of Object.entries(data.projects)) {
+                database.projects[id] = {
+                    id: String(project.id),
+                    name: String(project.name),
+                    status: String(project.status),
+                    folderID: project.folderID || null,
+                    sequential: Boolean(project.sequential),
+                    effectiveDueDate: project.effectiveDueDate,
+                    effectiveDeferDate: project.effectiveDeferDate,
+                    dueDate: project.dueDate,
+                    deferDate: project.deferDate,
+                    completedByChildren: Boolean(project.completedByChildren),
+                    containsSingletonActions: Boolean(project.containsSingletonActions),
+                    note: String(project.note || ""),
+                    tasks: project.tasks || [],
+                    flagged: false, // Default value
+                    estimatedMinutes: null // Default value
+                };
+            }
+        }
+        // Process folders
+        if (data.folders) {
+            for (const [id, folder] of Object.entries(data.folders)) {
+                database.folders[id] = {
+                    id: String(folder.id),
+                    name: String(folder.name),
+                    parentFolderID: folder.parentFolderID || null,
+                    status: String(folder.status),
+                    projects: folder.projects || [],
+                    subfolders: folder.subfolders || []
+                };
+            }
+        }
+        // Process tags
+        if (data.tags) {
+            for (const [id, tag] of Object.entries(data.tags)) {
+                database.tags[id] = {
+                    id: String(tag.id),
+                    name: String(tag.name),
+                    parentTagID: tag.parentTagID || null,
+                    active: Boolean(tag.active),
+                    allowsNextAction: Boolean(tag.allowsNextAction),
+                    tasks: tag.tasks || []
+                };
+            }
+        }
+        return database;
+    }
+    catch (error) {
+        console.error("Error in dumpDatabase:", error);
+        throw error;
+    }
+}

package/dist/tools/primitives/addOmniFocusTask.js

@@ -0,0 +1,157 @@
+import { exec } from 'child_process';
+import { promisify } from 'util';
+const execAsync = promisify(exec);
+/**
+ * Generate pure AppleScript for task creation
+ */
+function generateAppleScript(params) {
+    // Sanitize and prepare parameters for AppleScript
+    const name = params.name.replace(/['"\\]/g, '\\$&'); // Escape quotes and backslashes
+    const note = params.note?.replace(/['"\\]/g, '\\$&') || '';
+    const dueDate = params.dueDate || '';
+    const deferDate = params.deferDate || '';
+    const flagged = params.flagged === true;
+    const estimatedMinutes = params.estimatedMinutes?.toString() || '';
+    const tags = params.tags || [];
+    const projectName = params.projectName?.replace(/['"\\]/g, '\\$&') || '';
+    const parentTaskId = params.parentTaskId?.replace(/['"\\]/g, '\\$&') || '';
+    const parentTaskName = params.parentTaskName?.replace(/['"\\]/g, '\\$&') || '';
+    // Construct AppleScript with error handling
+    let script = `
+  try
+    tell application "OmniFocus"
+      tell front document
+        -- Determine the container (parent task, project, or inbox)
+        if "${parentTaskId}" is not "" then
+          -- Create subtask using parent task ID
+          try
+            set theParentTask to first flattened task where id = "${parentTaskId}"
+            set newTask to make new task with properties {name:"${name}"} at end of tasks of theParentTask
+          on error
+            return "{\\\"success\\\":false,\\\"error\\\":\\\"Parent task not found with ID: ${parentTaskId}\\\"}"
+          end try
+        else if "${parentTaskName}" is not "" then
+          -- Create subtask using parent task name
+          try
+            set theParentTask to first flattened task where name = "${parentTaskName}"
+            set newTask to make new task with properties {name:"${name}"} at end of tasks of theParentTask
+          on error
+            return "{\\\"success\\\":false,\\\"error\\\":\\\"Parent task not found with name: ${parentTaskName}\\\"}"
+          end try
+        else if "${projectName}" is not "" then
+          -- Use specified project
+          try
+            set theProject to first flattened project where name = "${projectName}"
+            set newTask to make new task with properties {name:"${name}"} at end of tasks of theProject
+          on error
+            return "{\\\"success\\\":false,\\\"error\\\":\\\"Project not found: ${projectName}\\\"}"
+          end try
+        else
+          -- Use inbox of the document
+          set newTask to make new inbox task with properties {name:"${name}"}
+        end if
+        
+        -- Set task properties
+        ${note ? `set note of newTask to "${note}"` : ''}
+        ${dueDate ? `
+          set due date of newTask to (current date) + (time to GMT)
+          set due date of newTask to date "${dueDate}"` : ''}
+        ${deferDate ? `
+          set defer date of newTask to (current date) + (time to GMT)
+          set defer date of newTask to date "${deferDate}"` : ''}
+        ${flagged ? `set flagged of newTask to true` : ''}
+        ${estimatedMinutes ? `set estimated minutes of newTask to ${estimatedMinutes}` : ''}
+        
+        -- Get the task ID
+        set taskId to id of newTask as string
+        
+        -- Add tags if provided
+        ${tags.length > 0 ? tags.map(tag => {
+        const sanitizedTag = tag.replace(/['"\\]/g, '\\$&');
+        return `
+          try
+            set theTag to first flattened tag where name = "${sanitizedTag}"
+            tell newTask to add theTag
+          on error
+            -- Ignore errors finding/adding tags
+          end try`;
+    }).join('\n') : ''}
+        
+        -- Return success with task ID
+        return "{\\\"success\\\":true,\\\"taskId\\\":\\"" & taskId & "\\",\\\"name\\\":\\"${name}\\"}"
+      end tell
+    end tell
+  on error errorMessage
+    return "{\\\"success\\\":false,\\\"error\\\":\\"" & errorMessage & "\\"}"
+  end try
+  `;
+    return script;
+}
+/**
+ * Validate parent task parameters to prevent conflicts
+ */
+async function validateParentTaskParams(params) {
+    // Check if both parentTaskId and parentTaskName are provided
+    if (params.parentTaskId && params.parentTaskName) {
+        return {
+            valid: false,
+            error: "Cannot specify both parentTaskId and parentTaskName. Please use only one."
+        };
+    }
+    // Check if parent task is specified along with projectName
+    if ((params.parentTaskId || params.parentTaskName) && params.projectName) {
+        return {
+            valid: false,
+            error: "Cannot specify both parent task and project. Subtasks inherit project from their parent."
+        };
+    }
+    return { valid: true };
+}
+/**
+ * Add a task to OmniFocus
+ */
+export async function addOmniFocusTask(params) {
+    try {
+        // Validate parent task parameters
+        const validation = await validateParentTaskParams(params);
+        if (!validation.valid) {
+            return {
+                success: false,
+                error: validation.error
+            };
+        }
+        // Generate AppleScript
+        const script = generateAppleScript(params);
+        console.error("Executing AppleScript directly...");
+        // Execute AppleScript directly
+        const { stdout, stderr } = await execAsync(`osascript -e '${script}'`);
+        if (stderr) {
+            console.error("AppleScript stderr:", stderr);
+        }
+        console.error("AppleScript stdout:", stdout);
+        // Parse the result
+        try {
+            const result = JSON.parse(stdout);
+            // Return the result
+            return {
+                success: result.success,
+                taskId: result.taskId,
+                error: result.error
+            };
+        }
+        catch (parseError) {
+            console.error("Error parsing AppleScript result:", parseError);
+            return {
+                success: false,
+                error: `Failed to parse result: ${stdout}`
+            };
+        }
+    }
+    catch (error) {
+        console.error("Error in addOmniFocusTask:", error);
+        return {
+            success: false,
+            error: error?.message || "Unknown error in addOmniFocusTask"
+        };
+    }
+}

package/dist/tools/primitives/addProject.js

@@ -0,0 +1,113 @@
+import { exec } from 'child_process';
+import { promisify } from 'util';
+const execAsync = promisify(exec);
+/**
+ * Generate pure AppleScript for project creation
+ */
+function generateAppleScript(params) {
+    // Sanitize and prepare parameters for AppleScript
+    const name = params.name.replace(/['"\\]/g, '\\$&'); // Escape quotes and backslashes
+    const note = params.note?.replace(/['"\\]/g, '\\$&') || '';
+    const dueDate = params.dueDate || '';
+    const deferDate = params.deferDate || '';
+    const flagged = params.flagged === true;
+    const estimatedMinutes = params.estimatedMinutes?.toString() || '';
+    const tags = params.tags || [];
+    const folderName = params.folderName?.replace(/['"\\]/g, '\\$&') || '';
+    const sequential = params.sequential === true;
+    // Construct AppleScript with error handling
+    let script = `
+  try
+    tell application "OmniFocus"
+      tell front document
+        -- Determine the container (root or folder)
+        if "${folderName}" is "" then
+          -- Create project at the root level
+          set newProject to make new project with properties {name:"${name}"}
+        else
+          -- Use specified folder
+          try
+            set theFolder to first flattened folder where name = "${folderName}"
+            set newProject to make new project with properties {name:"${name}"} at end of projects of theFolder
+          on error
+            return "{\\\"success\\\":false,\\\"error\\\":\\\"Folder not found: ${folderName}\\\"}"
+          end try
+        end if
+        
+        -- Set project properties
+        ${note ? `set note of newProject to "${note}"` : ''}
+        ${dueDate ? `
+          set due date of newProject to (current date) + (time to GMT)
+          set due date of newProject to date "${dueDate}"` : ''}
+        ${deferDate ? `
+          set defer date of newProject to (current date) + (time to GMT)
+          set defer date of newProject to date "${deferDate}"` : ''}
+        ${flagged ? `set flagged of newProject to true` : ''}
+        ${estimatedMinutes ? `set estimated minutes of newProject to ${estimatedMinutes}` : ''}
+        ${`set sequential of newProject to ${sequential}`}
+        
+        -- Get the project ID
+        set projectId to id of newProject as string
+        
+        -- Add tags if provided
+        ${tags.length > 0 ? tags.map(tag => {
+        const sanitizedTag = tag.replace(/['"\\]/g, '\\$&');
+        return `
+          try
+            set theTag to first flattened tag where name = "${sanitizedTag}"
+            tell newProject to add theTag
+          on error
+            -- Ignore errors finding/adding tags
+          end try`;
+    }).join('\n') : ''}
+        
+        -- Return success with project ID
+        return "{\\\"success\\\":true,\\\"projectId\\\":\\"" & projectId & "\\",\\\"name\\\":\\"${name}\\"}"
+      end tell
+    end tell
+  on error errorMessage
+    return "{\\\"success\\\":false,\\\"error\\\":\\"" & errorMessage & "\\"}"
+  end try
+  `;
+    return script;
+}
+/**
+ * Add a project to OmniFocus
+ */
+export async function addProject(params) {
+    try {
+        // Generate AppleScript
+        const script = generateAppleScript(params);
+        console.error("Executing AppleScript directly...");
+        // Execute AppleScript directly
+        const { stdout, stderr } = await execAsync(`osascript -e '${script}'`);
+        if (stderr) {
+            console.error("AppleScript stderr:", stderr);
+        }
+        console.error("AppleScript stdout:", stdout);
+        // Parse the result
+        try {
+            const result = JSON.parse(stdout);
+            // Return the result
+            return {
+                success: result.success,
+                projectId: result.projectId,
+                error: result.error
+            };
+        }
+        catch (parseError) {
+            console.error("Error parsing AppleScript result:", parseError);
+            return {
+                success: false,
+                error: `Failed to parse result: ${stdout}`
+            };
+        }
+    }
+    catch (error) {
+        console.error("Error in addProject:", error);
+        return {
+            success: false,
+            error: error?.message || "Unknown error in addProject"
+        };
+    }
+}

package/dist/tools/primitives/addSubtask.js

@@ -0,0 +1,37 @@
+import { addOmniFocusTask } from './addOmniFocusTask.js';
+/**
+ * Add a subtask to an existing task in OmniFocus
+ * This is a convenience function that wraps addOmniFocusTask with parent task parameters
+ */
+export async function addSubtask(params) {
+    // Validate that either parentTaskId or parentTaskName is provided
+    if (!params.parentTaskId && !params.parentTaskName) {
+        return {
+            success: false,
+            error: "Either parentTaskId or parentTaskName must be provided for subtask creation"
+        };
+    }
+    // Convert AddSubtaskParams to AddOmniFocusTaskParams
+    const taskParams = {
+        name: params.name,
+        note: params.note,
+        dueDate: params.dueDate,
+        deferDate: params.deferDate,
+        flagged: params.flagged,
+        estimatedMinutes: params.estimatedMinutes,
+        tags: params.tags,
+        parentTaskId: params.parentTaskId,
+        parentTaskName: params.parentTaskName,
+        // Don't set projectName for subtasks - they inherit from parent
+    };
+    try {
+        const result = await addOmniFocusTask(taskParams);
+        return result;
+    }
+    catch (error) {
+        return {
+            success: false,
+            error: error?.message || "Unknown error in addSubtask"
+        };
+    }
+}

package/dist/tools/primitives/batchAddItems.js

@@ -0,0 +1,87 @@
+import { addOmniFocusTask } from './addOmniFocusTask.js';
+import { addProject } from './addProject.js';
+/**
+ * Add multiple items (tasks or projects) to OmniFocus
+ */
+export async function batchAddItems(items) {
+    try {
+        // Results array to track individual operation outcomes
+        const results = [];
+        // Process each item in sequence
+        for (const item of items) {
+            try {
+                if (item.type === 'task') {
+                    // Extract task-specific params
+                    const taskParams = {
+                        name: item.name,
+                        note: item.note,
+                        dueDate: item.dueDate,
+                        deferDate: item.deferDate,
+                        flagged: item.flagged,
+                        estimatedMinutes: item.estimatedMinutes,
+                        tags: item.tags,
+                        projectName: item.projectName,
+                        parentTaskId: item.parentTaskId,
+                        parentTaskName: item.parentTaskName
+                    };
+                    // Add task
+                    const taskResult = await addOmniFocusTask(taskParams);
+                    results.push({
+                        success: taskResult.success,
+                        id: taskResult.taskId,
+                        error: taskResult.error
+                    });
+                }
+                else if (item.type === 'project') {
+                    // Extract project-specific params
+                    const projectParams = {
+                        name: item.name,
+                        note: item.note,
+                        dueDate: item.dueDate,
+                        deferDate: item.deferDate,
+                        flagged: item.flagged,
+                        estimatedMinutes: item.estimatedMinutes,
+                        tags: item.tags,
+                        folderName: item.folderName,
+                        sequential: item.sequential
+                    };
+                    // Add project
+                    const projectResult = await addProject(projectParams);
+                    results.push({
+                        success: projectResult.success,
+                        id: projectResult.projectId,
+                        error: projectResult.error
+                    });
+                }
+                else {
+                    // Invalid type
+                    results.push({
+                        success: false,
+                        error: `Invalid item type: ${item.type}`
+                    });
+                }
+            }
+            catch (itemError) {
+                // Handle individual item errors
+                results.push({
+                    success: false,
+                    error: itemError.message || "Unknown error processing item"
+                });
+            }
+        }
+        // Determine overall success (true if at least one item was added successfully)
+        const overallSuccess = results.some(result => result.success);
+        return {
+            success: overallSuccess,
+            results: results
+        };
+    }
+    catch (error) {
+        console.error("Error in batchAddItems:", error);
+        return {
+            success: false,
+            results: [],
+            error: error.message || "Unknown error in batchAddItems"
+        };
+    }
+}

package/dist/tools/primitives/batchRemoveItems.js

@@ -0,0 +1,44 @@
+import { removeItem } from './removeItem.js';
+/**
+ * Remove multiple items (tasks or projects) from OmniFocus
+ */
+export async function batchRemoveItems(items) {
+    try {
+        // Results array to track individual operation outcomes
+        const results = [];
+        // Process each item in sequence
+        for (const item of items) {
+            try {
+                // Remove item
+                const itemResult = await removeItem(item);
+                results.push({
+                    success: itemResult.success,
+                    id: itemResult.id,
+                    name: itemResult.name,
+                    error: itemResult.error
+                });
+            }
+            catch (itemError) {
+                // Handle individual item errors
+                results.push({
+                    success: false,
+                    error: itemError.message || "Unknown error processing item"
+                });
+            }
+        }
+        // Determine overall success (true if at least one item was removed successfully)
+        const overallSuccess = results.some(result => result.success);
+        return {
+            success: overallSuccess,
+            results: results
+        };
+    }
+    catch (error) {
+        console.error("Error in batchRemoveItems:", error);
+        return {
+            success: false,
+            results: [],
+            error: error.message || "Unknown error in batchRemoveItems"
+        };
+    }
+}