@iflow-mcp/omnifocus-mcp 1.2.3

package/dist/tools/primitives/queryOmnifocus.js

@@ -0,0 +1,365 @@
+import { executeOmniFocusScript } from '../../utils/scriptExecution.js';
+export async function queryOmnifocus(params) {
+    try {
+        // Create JXA script for the query
+        const jxaScript = generateQueryScript(params);
+        // Write script to temp file and execute
+        const tempFile = `/tmp/omnifocus_query_${Date.now()}.js`;
+        const fs = await import('fs');
+        fs.writeFileSync(tempFile, jxaScript);
+        // Execute the script
+        const result = await executeOmniFocusScript(tempFile);
+        // Clean up temp file
+        fs.unlinkSync(tempFile);
+        if (result.error) {
+            return {
+                success: false,
+                error: result.error
+            };
+        }
+        return {
+            success: true,
+            items: params.summary ? undefined : result.items,
+            count: result.count
+        };
+    }
+    catch (error) {
+        console.error('Error querying OmniFocus:', error);
+        return {
+            success: false,
+            error: error instanceof Error ? error.message : 'Unknown error occurred'
+        };
+    }
+}
+function generateQueryScript(params) {
+    const { entity, filters = {}, fields, limit, sortBy, sortOrder, includeCompleted = false, summary = false } = params;
+    // Build the JXA script based on the entity type and filters
+    return `(() => {
+    try {
+      const startTime = new Date();
+      
+      // Helper function to format dates
+      function formatDate(date) {
+        if (!date) return null;
+        return date.toISOString();
+      }
+      
+      // Helper to check date filters
+      function checkDateFilter(itemDate, daysFromNow) {
+        if (!itemDate) return false;
+        const futureDate = new Date();
+        futureDate.setDate(futureDate.getDate() + daysFromNow);
+        return itemDate <= futureDate;
+      }
+      
+      // Status mappings
+      const taskStatusMap = {
+        [Task.Status.Available]: "Available",
+        [Task.Status.Blocked]: "Blocked", 
+        [Task.Status.Completed]: "Completed",
+        [Task.Status.Dropped]: "Dropped",
+        [Task.Status.DueSoon]: "DueSoon",
+        [Task.Status.Next]: "Next",
+        [Task.Status.Overdue]: "Overdue"
+      };
+      
+      const projectStatusMap = {
+        [Project.Status.Active]: "Active",
+        [Project.Status.Done]: "Done",
+        [Project.Status.Dropped]: "Dropped",
+        [Project.Status.OnHold]: "OnHold"
+      };
+      
+      // Get the appropriate collection based on entity type
+      let items = [];
+      const entityType = "${entity}";
+      
+      if (entityType === "tasks") {
+        items = flattenedTasks;
+      } else if (entityType === "projects") {
+        items = flattenedProjects;
+      } else if (entityType === "folders") {
+        items = flattenedFolders;
+      }
+      
+      // Apply filters
+      let filtered = items.filter(item => {
+        // Skip completed/dropped unless explicitly requested
+        if (!${includeCompleted}) {
+          if (entityType === "tasks") {
+            if (item.taskStatus === Task.Status.Completed || 
+                item.taskStatus === Task.Status.Dropped) {
+              return false;
+            }
+          } else if (entityType === "projects") {
+            if (item.status === Project.Status.Done || 
+                item.status === Project.Status.Dropped) {
+              return false;
+            }
+          }
+        }
+        
+        // Apply specific filters
+        ${generateFilterConditions(entity, filters)}
+        
+        return true;
+      });
+      
+      // Apply sorting if specified
+      ${sortBy ? generateSortLogic(sortBy, sortOrder) : ''}
+      
+      // Apply limit if specified
+      ${limit ? `filtered = filtered.slice(0, ${limit});` : ''}
+      
+      // If summary mode, just return count
+      if (${summary}) {
+        return JSON.stringify({
+          count: filtered.length,
+          error: null
+        });
+      }
+      
+      // Transform items to return only requested fields
+      const results = filtered.map(item => {
+        ${generateFieldMapping(entity, fields)}
+      });
+      
+      return JSON.stringify({
+        items: results,
+        count: results.length,
+        error: null
+      });
+      
+    } catch (error) {
+      return JSON.stringify({
+        error: "Script execution error: " + error.toString(),
+        items: [],
+        count: 0
+      });
+    }
+  })();`;
+}
+function generateFilterConditions(entity, filters) {
+    const conditions = [];
+    if (entity === 'tasks') {
+        if (filters.projectName) {
+            conditions.push(`
+        if (item.containingProject) {
+          const projectName = item.containingProject.name.toLowerCase();
+          if (!projectName.includes("${filters.projectName.toLowerCase()}")) return false;
+        } else if ("${filters.projectName.toLowerCase()}" !== "inbox") {
+          return false;
+        }
+      `);
+        }
+        if (filters.projectId) {
+            conditions.push(`
+        if (!item.containingProject || 
+            item.containingProject.id.primaryKey !== "${filters.projectId}") {
+          return false;
+        }
+      `);
+        }
+        if (filters.tags && filters.tags.length > 0) {
+            const tagCondition = filters.tags.map((tag) => `item.tags.some(t => t.name === "${tag}")`).join(' || ');
+            conditions.push(`if (!(${tagCondition})) return false;`);
+        }
+        if (filters.status && filters.status.length > 0) {
+            const statusCondition = filters.status.map((status) => `taskStatusMap[item.taskStatus] === "${status}"`).join(' || ');
+            conditions.push(`if (!(${statusCondition})) return false;`);
+        }
+        if (filters.flagged !== undefined) {
+            conditions.push(`if (item.flagged !== ${filters.flagged}) return false;`);
+        }
+        if (filters.dueWithin !== undefined) {
+            conditions.push(`
+        if (!item.dueDate || !checkDateFilter(item.dueDate, ${filters.dueWithin})) {
+          return false;
+        }
+      `);
+        }
+        if (filters.hasNote !== undefined) {
+            conditions.push(`
+        const hasNote = item.note && item.note.trim().length > 0;
+        if (hasNote !== ${filters.hasNote}) return false;
+      `);
+        }
+    }
+    if (entity === 'projects') {
+        if (filters.folderId) {
+            conditions.push(`
+        if (!item.parentFolder || 
+            item.parentFolder.id.primaryKey !== "${filters.folderId}") {
+          return false;
+        }
+      `);
+        }
+        if (filters.status && filters.status.length > 0) {
+            const statusCondition = filters.status.map((status) => `projectStatusMap[item.status] === "${status}"`).join(' || ');
+            conditions.push(`if (!(${statusCondition})) return false;`);
+        }
+    }
+    return conditions.join('\n');
+}
+function generateSortLogic(sortBy, sortOrder) {
+    const order = sortOrder === 'desc' ? -1 : 1;
+    return `
+    filtered.sort((a, b) => {
+      let aVal = a.${sortBy};
+      let bVal = b.${sortBy};
+      
+      // Handle null/undefined values
+      if (aVal == null && bVal == null) return 0;
+      if (aVal == null) return 1;
+      if (bVal == null) return -1;
+      
+      // Compare based on type
+      if (typeof aVal === 'string') {
+        return aVal.localeCompare(bVal) * ${order};
+      } else if (aVal instanceof Date) {
+        return (aVal.getTime() - bVal.getTime()) * ${order};
+      } else {
+        return (aVal - bVal) * ${order};
+      }
+    });
+  `;
+}
+function generateFieldMapping(entity, fields) {
+    // If no specific fields requested, return common fields based on entity
+    if (!fields || fields.length === 0) {
+        if (entity === 'tasks') {
+            return `
+        const obj = {
+          id: item.id.primaryKey,
+          name: item.name || "",
+          flagged: item.flagged || false,
+          taskStatus: taskStatusMap[item.taskStatus] || "Unknown",
+          dueDate: formatDate(item.dueDate),
+          deferDate: formatDate(item.deferDate),
+          tagNames: item.tags ? item.tags.map(t => t.name) : [],
+          projectName: item.containingProject ? item.containingProject.name : (item.inInbox ? "Inbox" : null),
+          estimatedMinutes: item.estimatedMinutes || null
+        };
+        if (item.note && item.note.trim()) obj.note = item.note;
+        return obj;
+      `;
+        }
+        else if (entity === 'projects') {
+            return `
+        const taskArray = item.tasks || [];
+        return {
+          id: item.id.primaryKey,
+          name: item.name || "",
+          status: projectStatusMap[item.status] || "Unknown",
+          folderName: item.parentFolder ? item.parentFolder.name : null,
+          taskCount: taskArray.length,
+          flagged: item.flagged || false,
+          dueDate: formatDate(item.dueDate),
+          deferDate: formatDate(item.deferDate)
+        };
+      `;
+        }
+        else if (entity === 'folders') {
+            return `
+        const projectArray = item.projects || [];
+        return {
+          id: item.id.primaryKey,
+          name: item.name || "",
+          projectCount: projectArray.length,
+          path: item.container ? item.container.name + "/" + item.name : item.name
+        };
+      `;
+        }
+    }
+    // Generate mapping for specific fields
+    const mappings = fields.map(field => {
+        // Handle special field mappings based on entity type
+        if (field === 'id') {
+            return `id: item.id.primaryKey`;
+        }
+        else if (field === 'taskStatus') {
+            return `taskStatus: taskStatusMap[item.taskStatus]`;
+        }
+        else if (field === 'status') {
+            return `status: projectStatusMap[item.status]`;
+        }
+        else if (field === 'modificationDate' || field === 'modified') {
+            return `modificationDate: formatDate(item.modified)`;
+        }
+        else if (field === 'creationDate' || field === 'added') {
+            return `creationDate: formatDate(item.added)`;
+        }
+        else if (field === 'completionDate') {
+            return `completionDate: item.completionDate ? formatDate(item.completionDate) : null`;
+        }
+        else if (field === 'dueDate') {
+            return `dueDate: formatDate(item.dueDate)`;
+        }
+        else if (field === 'deferDate') {
+            return `deferDate: formatDate(item.deferDate)`;
+        }
+        else if (field === 'effectiveDueDate') {
+            return `effectiveDueDate: formatDate(item.effectiveDueDate)`;
+        }
+        else if (field === 'effectiveDeferDate') {
+            return `effectiveDeferDate: formatDate(item.effectiveDeferDate)`;
+        }
+        else if (field === 'tagNames') {
+            return `tagNames: item.tags ? item.tags.map(t => t.name) : []`;
+        }
+        else if (field === 'tags') {
+            return `tags: item.tags ? item.tags.map(t => t.id.primaryKey) : []`;
+        }
+        else if (field === 'projectName') {
+            return `projectName: item.containingProject ? item.containingProject.name : (item.inInbox ? "Inbox" : null)`;
+        }
+        else if (field === 'projectId') {
+            return `projectId: item.containingProject ? item.containingProject.id.primaryKey : null`;
+        }
+        else if (field === 'parentId') {
+            return `parentId: item.parent ? item.parent.id.primaryKey : null`;
+        }
+        else if (field === 'childIds') {
+            return `childIds: item.children ? item.children.map(c => c.id.primaryKey) : []`;
+        }
+        else if (field === 'hasChildren') {
+            return `hasChildren: item.children ? item.children.length > 0 : false`;
+        }
+        else if (field === 'folderName') {
+            return `folderName: item.parentFolder ? item.parentFolder.name : null`;
+        }
+        else if (field === 'folderID') {
+            return `folderID: item.parentFolder ? item.parentFolder.id.primaryKey : null`;
+        }
+        else if (field === 'taskCount') {
+            return `taskCount: item.tasks ? item.tasks.length : 0`;
+        }
+        else if (field === 'tasks') {
+            return `tasks: item.tasks ? item.tasks.map(t => t.id.primaryKey) : []`;
+        }
+        else if (field === 'projectCount') {
+            return `projectCount: item.projects ? item.projects.length : 0`;
+        }
+        else if (field === 'projects') {
+            return `projects: item.projects ? item.projects.map(p => p.id.primaryKey) : []`;
+        }
+        else if (field === 'subfolders') {
+            return `subfolders: item.folders ? item.folders.map(f => f.id.primaryKey) : []`;
+        }
+        else if (field === 'path') {
+            return `path: item.container ? item.container.name + "/" + item.name : item.name`;
+        }
+        else if (field === 'estimatedMinutes') {
+            return `estimatedMinutes: item.estimatedMinutes || null`;
+        }
+        else {
+            // Default: try to access the field directly
+            return `${field}: item.${field} !== undefined ? item.${field} : null`;
+        }
+    }).join(',\n          ');
+    return `
+    return {
+      ${mappings}
+    };
+  `;
+}

package/dist/tools/primitives/queryOmnifocusDebug.js

@@ -0,0 +1,135 @@
+import { executeOmniFocusScript } from '../../utils/scriptExecution.js';
+/**
+ * Debug version of queryOmnifocus that returns raw field information
+ * Useful for understanding what fields are available in OmniFocus
+ */
+export async function queryOmnifocusDebug(entity) {
+    const script = `
+    (() => {
+      try {
+        // Get first item of the requested type
+        let item;
+        const entityType = "${entity}";
+        
+        if (entityType === "task") {
+          item = flattenedTasks[0];
+        } else if (entityType === "project") {
+          item = flattenedProjects[0];
+        } else if (entityType === "folder") {
+          item = flattenedFolders[0];
+        }
+        
+        if (!item) {
+          return JSON.stringify({ error: "No items found" });
+        }
+        
+        // Get all properties of the item
+        const properties = {};
+        const skipProps = ['constructor', 'toString', 'valueOf'];
+        
+        for (let prop in item) {
+          if (skipProps.includes(prop)) continue;
+          
+          try {
+            const value = item[prop];
+            const valueType = typeof value;
+            
+            if (value === null) {
+              properties[prop] = { type: 'null', value: null };
+            } else if (value === undefined) {
+              properties[prop] = { type: 'undefined', value: undefined };
+            } else if (valueType === 'function') {
+              properties[prop] = { type: 'function', value: '[Function]' };
+            } else if (value instanceof Date) {
+              properties[prop] = { type: 'Date', value: value.toISOString() };
+            } else if (Array.isArray(value)) {
+              properties[prop] = { 
+                type: 'Array', 
+                length: value.length,
+                sample: value.length > 0 ? value[0] : null
+              };
+            } else if (valueType === 'object') {
+              // Try to get ID if it's an OmniFocus object
+              if (value.id && value.id.primaryKey) {
+                properties[prop] = { 
+                  type: 'OFObject',
+                  id: value.id.primaryKey,
+                  name: value.name || null
+                };
+              } else {
+                properties[prop] = { type: 'object', keys: Object.keys(value) };
+              }
+            } else {
+              properties[prop] = { type: valueType, value: value };
+            }
+          } catch (e) {
+            properties[prop] = { type: 'error', error: e.toString() };
+          }
+        }
+        
+        // Also check specific expected properties
+        const checkProps = [
+          'id', 'name', 'note', 'flagged', 'dueDate', 'deferDate',
+          'estimatedMinutes', 'modificationDate', 'creationDate',
+          'completionDate', 'taskStatus', 'status', 'tasks', 'projects',
+          'containingProject', 'parentFolder', 'parent', 'children'
+        ];
+        
+        const expectedProps = {};
+        checkProps.forEach(prop => {
+          try {
+            const value = item[prop];
+            if (value !== undefined) {
+              if (value && value.id && value.id.primaryKey) {
+                expectedProps[prop] = {
+                  exists: true,
+                  type: 'OFObject',
+                  id: value.id.primaryKey
+                };
+              } else if (value instanceof Date) {
+                expectedProps[prop] = {
+                  exists: true,
+                  type: 'Date',
+                  value: value.toISOString()
+                };
+              } else if (Array.isArray(value)) {
+                expectedProps[prop] = {
+                  exists: true,
+                  type: 'Array',
+                  length: value.length
+                };
+              } else {
+                expectedProps[prop] = {
+                  exists: true,
+                  type: typeof value,
+                  value: value
+                };
+              }
+            } else {
+              expectedProps[prop] = { exists: false };
+            }
+          } catch (e) {
+            expectedProps[prop] = { exists: false, error: e.toString() };
+          }
+        });
+        
+        return JSON.stringify({
+          entityType: entityType,
+          itemName: item.name || 'Unnamed',
+          allProperties: properties,
+          expectedProperties: expectedProps
+        }, null, 2);
+        
+      } catch (error) {
+        return JSON.stringify({ error: error.toString() });
+      }
+    })();
+  `;
+    // Write script to temp file and execute
+    const fs = await import('fs');
+    const tempFile = `/tmp/omnifocus_debug_${Date.now()}.js`;
+    fs.writeFileSync(tempFile, script);
+    const result = await executeOmniFocusScript(tempFile);
+    fs.unlinkSync(tempFile);
+    return result;
+}

package/dist/tools/primitives/removeItem.js

@@ -0,0 +1,177 @@
+import { exec } from 'child_process';
+import { promisify } from 'util';
+const execAsync = promisify(exec);
+/**
+ * Generate pure AppleScript for item removal
+ */
+function generateAppleScript(params) {
+    // Sanitize and prepare parameters for AppleScript
+    const id = params.id?.replace(/['"\\]/g, '\\$&') || ''; // Escape quotes and backslashes
+    const name = params.name?.replace(/['"\\]/g, '\\$&') || '';
+    const itemType = params.itemType;
+    // Verify we have at least one identifier
+    if (!id && !name) {
+        return `return "{\\\"success\\\":false,\\\"error\\\":\\\"Either id or name must be provided\\\"}"`;
+    }
+    // Construct AppleScript with error handling
+    let script = `
+  try
+    tell application "OmniFocus"
+      tell front document
+        -- Find the item to remove
+        set foundItem to missing value
+`;
+    // Add ID search if provided
+    if (id) {
+        if (itemType === 'task') {
+            script += `
+        -- Try to find task by ID (search in projects first, then inbox)
+        try
+          set foundItem to first flattened task where id = "${id}"
+        end try
+        
+        -- If not found in projects, search in inbox
+        if foundItem is missing value then
+          try
+            set foundItem to first inbox task where id = "${id}"
+          end try
+        end if
+`;
+        }
+        else {
+            script += `
+        -- Try to find project by ID
+        try
+          set foundItem to first flattened project where id = "${id}"
+        end try
+`;
+        }
+    }
+    // Add name search if provided (and no ID or as fallback)
+    if (!id && name) {
+        if (itemType === 'task') {
+            script += `
+        -- Find task by name (search in projects first, then inbox)
+        try
+          set foundItem to first flattened task where name = "${name}"
+        end try
+        
+        -- If not found in projects, search in inbox
+        if foundItem is missing value then
+          try
+            set foundItem to first inbox task where name = "${name}"
+          end try
+        end if
+`;
+        }
+        else {
+            script += `
+        -- Find project by name
+        try
+          set foundItem to first flattened project where name = "${name}"
+        end try
+`;
+        }
+    }
+    else if (id && name) {
+        if (itemType === 'task') {
+            script += `
+        -- If ID search failed, try to find by name as fallback
+        if foundItem is missing value then
+          try
+            set foundItem to first flattened task where name = "${name}"
+          end try
+        end if
+        
+        -- If still not found, search in inbox
+        if foundItem is missing value then
+          try
+            set foundItem to first inbox task where name = "${name}"
+          end try
+        end if
+`;
+        }
+        else {
+            script += `
+        -- If ID search failed, try to find project by name as fallback
+        if foundItem is missing value then
+          try
+            set foundItem to first flattened project where name = "${name}"
+          end try
+        end if
+`;
+        }
+    }
+    // Add the rest of the script
+    script += `
+        -- If we found the item, remove it
+        if foundItem is not missing value then
+          set itemName to name of foundItem
+          set itemId to id of foundItem as string
+          
+          -- Delete the item
+          delete foundItem
+          
+          -- Return success
+          return "{\\\"success\\\":true,\\\"id\\\":\\"" & itemId & "\\",\\\"name\\\":\\"" & itemName & "\\"}"
+        else
+          -- Item not found
+          return "{\\\"success\\\":false,\\\"error\\\":\\\"Item not found\\\"}"
+        end if
+      end tell
+    end tell
+  on error errorMessage
+    return "{\\\"success\\\":false,\\\"error\\\":\\"" & errorMessage & "\\"}"
+  end try
+  `;
+    return script;
+}
+/**
+ * Remove a task or project from OmniFocus
+ */
+export async function removeItem(params) {
+    try {
+        // Generate AppleScript
+        const script = generateAppleScript(params);
+        console.error("Executing AppleScript for removal...");
+        console.error(`Item type: ${params.itemType}, ID: ${params.id || 'not provided'}, Name: ${params.name || 'not provided'}`);
+        // Log a preview of the script for debugging (first few lines)
+        const scriptPreview = script.split('\n').slice(0, 10).join('\n') + '\n...';
+        console.error("AppleScript preview:\n", scriptPreview);
+        // 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,
+                id: result.id,
+                name: result.name,
+                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 removeItem execution:", error);
+        // Include more detailed error information
+        if (error.message && error.message.includes('syntax error')) {
+            console.error("This appears to be an AppleScript syntax error. Review the script generation logic.");
+        }
+        return {
+            success: false,
+            error: error?.message || "Unknown error in removeItem"
+        };
+    }
+}

package/dist/types.js

@@ -0,0 +1 @@
+export {};