@iflow-mcp/omnifocus-mcp 1.2.3

package/dist/utils/cacheManager.js

@@ -0,0 +1,187 @@
+import { executeOmniFocusScript } from './scriptExecution.js';
+class OmniFocusCacheManager {
+    cache = new Map();
+    options;
+    totalSize = 0;
+    constructor(options = {}) {
+        this.options = {
+            ttlSeconds: options.ttlSeconds ?? 300, // 5 minutes default
+            maxSize: options.maxSize ?? 50, // 50MB default
+            useChecksum: options.useChecksum ?? true
+        };
+    }
+    /**
+     * Get cached data if valid, otherwise return null
+     */
+    async get(key) {
+        const entry = this.cache.get(key);
+        if (!entry) {
+            return null;
+        }
+        // Check if cache has expired
+        const age = Date.now() - entry.timestamp.getTime();
+        if (age > this.options.ttlSeconds * 1000) {
+            this.cache.delete(key);
+            return null;
+        }
+        // If using checksums, validate the cache is still current
+        if (this.options.useChecksum && entry.checksum) {
+            const currentChecksum = await this.getDatabaseChecksum();
+            if (currentChecksum !== entry.checksum) {
+                this.cache.delete(key);
+                return null;
+            }
+        }
+        return entry.data;
+    }
+    /**
+     * Store data in cache
+     */
+    async set(key, data) {
+        // Estimate size (rough approximation)
+        const dataSize = JSON.stringify(data).length / (1024 * 1024); // Convert to MB
+        // Check if adding this would exceed max size
+        if (this.totalSize + dataSize > this.options.maxSize) {
+            this.evictOldest();
+        }
+        const checksum = this.options.useChecksum ? await this.getDatabaseChecksum() : undefined;
+        this.cache.set(key, {
+            data,
+            timestamp: new Date(),
+            checksum
+        });
+        this.totalSize += dataSize;
+    }
+    /**
+     * Invalidate specific cache entry
+     */
+    invalidate(key) {
+        this.cache.delete(key);
+    }
+    /**
+     * Clear all cache entries
+     */
+    clear() {
+        this.cache.clear();
+        this.totalSize = 0;
+    }
+    /**
+     * Get cache statistics
+     */
+    getStats() {
+        let oldestEntry = null;
+        this.cache.forEach(entry => {
+            if (!oldestEntry || entry.timestamp < oldestEntry) {
+                oldestEntry = entry.timestamp;
+            }
+        });
+        return {
+            entries: this.cache.size,
+            sizeEstimateMB: this.totalSize,
+            oldestEntry,
+            hitRate: this.calculateHitRate()
+        };
+    }
+    /**
+     * Get a lightweight checksum of the database state
+     */
+    async getDatabaseChecksum() {
+        try {
+            const script = `
+        (() => {
+          try {
+            // Get counts and latest modification times as a simple checksum
+            const taskCount = flattenedTasks.length;
+            const projectCount = flattenedProjects.length;
+            
+            // Get the most recent modification time
+            let latestMod = new Date(0);
+            
+            flattenedTasks.forEach(task => {
+              if (task.modificationDate && task.modificationDate > latestMod) {
+                latestMod = task.modificationDate;
+              }
+            });
+            
+            flattenedProjects.forEach(project => {
+              if (project.modificationDate && project.modificationDate > latestMod) {
+                latestMod = project.modificationDate;
+              }
+            });
+            
+            // Create a simple checksum string
+            const checksum = taskCount + "-" + projectCount + "-" + latestMod.getTime();
+            
+            return JSON.stringify({ checksum });
+          } catch (error) {
+            return JSON.stringify({ checksum: "error-" + Date.now() });
+          }
+        })();
+      `;
+            // Write to temp file and execute
+            const fs = await import('fs');
+            const tempFile = `/tmp/omnifocus_checksum_${Date.now()}.js`;
+            fs.writeFileSync(tempFile, script);
+            const result = await executeOmniFocusScript(tempFile);
+            fs.unlinkSync(tempFile);
+            return result.checksum || `fallback-${Date.now()}`;
+        }
+        catch (error) {
+            console.error('Error getting database checksum:', error);
+            return `error-${Date.now()}`;
+        }
+    }
+    /**
+     * Evict oldest cache entries when size limit is reached
+     */
+    evictOldest() {
+        let oldestKey = null;
+        let oldestTime = new Date();
+        this.cache.forEach((entry, key) => {
+            if (entry.timestamp < oldestTime) {
+                oldestTime = entry.timestamp;
+                oldestKey = key;
+            }
+        });
+        if (oldestKey) {
+            this.cache.delete(oldestKey);
+            // Recalculate total size (simplified for now)
+            this.totalSize *= 0.9;
+        }
+    }
+    // Tracking for hit rate calculation
+    hits = 0;
+    misses = 0;
+    calculateHitRate() {
+        const total = this.hits + this.misses;
+        if (total === 0)
+            return 0;
+        return (this.hits / total) * 100;
+    }
+    trackHit() {
+        this.hits++;
+    }
+    trackMiss() {
+        this.misses++;
+    }
+}
+// Singleton instance
+let cacheManager = null;
+/**
+ * Get or create the cache manager instance
+ */
+export function getCacheManager(options) {
+    if (!cacheManager) {
+        cacheManager = new OmniFocusCacheManager(options);
+    }
+    return cacheManager;
+}
+/**
+ * Reset the cache manager (useful for testing)
+ */
+export function resetCacheManager() {
+    if (cacheManager) {
+        cacheManager.clear();
+    }
+    cacheManager = null;
+}

package/dist/utils/dateFormatting.js

@@ -0,0 +1,58 @@
+/**
+ * Version 2 of date formatting utilities that work around AppleScript restrictions
+ * Dates must be constructed outside of tell blocks
+ */
+/**
+ * Generate AppleScript to construct a date variable outside tell blocks
+ * @param isoDateString - ISO format date string
+ * @param varName - Name for the date variable
+ * @returns AppleScript code to construct the date
+ */
+export function createDateOutsideTellBlock(isoDateString, varName) {
+    // Parse the ISO date string
+    const date = new Date(isoDateString);
+    // Check if the date is valid
+    if (isNaN(date.getTime())) {
+        throw new Error(`Invalid date string: ${isoDateString}`);
+    }
+    // Extract date components
+    const year = date.getFullYear();
+    const month = date.getMonth() + 1; // JavaScript months are 0-indexed
+    const day = date.getDate();
+    const hours = date.getHours();
+    const minutes = date.getMinutes();
+    const seconds = date.getSeconds();
+    // Generate AppleScript to construct date outside tell blocks
+    return `copy current date to ${varName}
+set year of ${varName} to ${year}
+set month of ${varName} to ${month}
+set day of ${varName} to ${day}
+set hours of ${varName} to ${hours}
+set minutes of ${varName} to ${minutes}
+set seconds of ${varName} to ${seconds}`;
+}
+/**
+ * Generate date assignment that works with AppleScript restrictions
+ */
+export function generateDateAssignmentV2(objectName, propertyName, isoDateString) {
+    if (isoDateString === undefined) {
+        return null; // No date change requested
+    }
+    if (isoDateString === '') {
+        // Clear the date
+        return {
+            preScript: '',
+            assignmentScript: `set ${propertyName} of ${objectName} to missing value`
+        };
+    }
+    // Generate unique variable name
+    const varName = `dateVar${Math.random().toString(36).substr(2, 9)}`;
+    // Generate the date construction (outside tell blocks)
+    const preScript = createDateOutsideTellBlock(isoDateString, varName);
+    // Generate the assignment (inside tell blocks)
+    const assignmentScript = `set ${propertyName} of ${objectName} to ${varName}`;
+    return {
+        preScript,
+        assignmentScript
+    };
+}

package/dist/utils/omnifocusScripts/getPerspectiveView.js

@@ -0,0 +1,169 @@
+// OmniJS script to get the current perspective view in OmniFocus
+(() => {
+  try {
+    // Note: We can't easily switch perspectives via OmniJS
+    // We can only report what's currently visible in the window
+    
+    // Get the current window and its perspective
+    const window = document.windows[0];
+    if (!window) {
+      return JSON.stringify({
+        success: false,
+        error: "No OmniFocus window is open"
+      });
+    }
+    
+    // Get the current perspective
+    const currentPerspective = window.perspective;
+    let perspectiveName = "Unknown";
+    
+    // Identify the perspective
+    if (currentPerspective) {
+      if (currentPerspective === Perspective.BuiltIn.Inbox) {
+        perspectiveName = "Inbox";
+      } else if (currentPerspective === Perspective.BuiltIn.Projects) {
+        perspectiveName = "Projects";
+      } else if (currentPerspective === Perspective.BuiltIn.Tags) {
+        perspectiveName = "Tags";
+      } else if (currentPerspective === Perspective.BuiltIn.Forecast) {
+        perspectiveName = "Forecast";
+      } else if (currentPerspective === Perspective.BuiltIn.Flagged) {
+        perspectiveName = "Flagged";
+      } else if (currentPerspective === Perspective.BuiltIn.Review) {
+        perspectiveName = "Review";
+      } else if (currentPerspective.name) {
+        // Custom perspective
+        perspectiveName = currentPerspective.name;
+      }
+    }
+    
+    // Get visible items based on the perspective
+    const items = [];
+    const selection = window.selection;
+    const selectedTasks = selection.tasks;
+    const selectedProjects = selection.projects;
+    
+    // Helper function to format dates
+    function formatDate(date) {
+      if (!date) return null;
+      return date.toISOString();
+    }
+    
+    // Helper to get task details
+    function getTaskDetails(task) {
+      const details = {
+        id: task.id.primaryKey,
+        name: task.name,
+        completed: task.completed,
+        flagged: task.flagged,
+        note: task.note || '',
+        dueDate: formatDate(task.dueDate),
+        deferDate: formatDate(task.deferDate),
+        completionDate: formatDate(task.completionDate),
+        estimatedMinutes: task.estimatedMinutes
+      };
+      
+      // Task status
+      const statusMap = {
+        [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"
+      };
+      details.taskStatus = statusMap[task.taskStatus] || "Unknown";
+      
+      // Project context
+      const project = task.containingProject;
+      details.projectName = project ? project.name : null;
+      
+      // Tags
+      details.tagNames = task.tags.map(tag => tag.name);
+      
+      return details;
+    }
+    
+    // Get project details
+    function getProjectDetails(project) {
+      return {
+        id: project.id.primaryKey,
+        name: project.name,
+        type: 'project',
+        status: project.status,
+        note: project.note || '',
+        flagged: project.flagged || false,
+        dueDate: formatDate(project.dueDate),
+        deferDate: formatDate(project.deferDate),
+        folderName: project.parentFolder ? project.parentFolder.name : null
+      };
+    }
+    
+    // Try to get content based on perspective type
+    if (perspectiveName === "Inbox") {
+      // Get inbox tasks - inbox is a global in OmniJS
+      inbox.forEach(task => {
+        items.push(getTaskDetails(task));
+      });
+    } else if (perspectiveName === "Projects") {
+      // Get all projects - using flattenedProjects global
+      flattenedProjects.forEach(project => {
+        if (project.status === Project.Status.Active) {
+          items.push(getProjectDetails(project));
+        }
+      });
+    } else if (perspectiveName === "Tags") {
+      // Get tagged tasks - using flattenedTags global
+      flattenedTags.forEach(tag => {
+        tag.remainingTasks.forEach(task => {
+          const taskDetail = getTaskDetails(task);
+          if (!items.some(item => item.id === taskDetail.id)) {
+            items.push(taskDetail);
+          }
+        });
+      });
+    } else if (perspectiveName === "Flagged") {
+      // Get flagged items - using flattenedTasks global
+      flattenedTasks.forEach(task => {
+        if (task.flagged && !task.completed) {
+          items.push(getTaskDetails(task));
+        }
+      });
+    } else {
+      // For other perspectives, try to get selected or visible items
+      if (selectedTasks.length > 0) {
+        selectedTasks.forEach(task => {
+          items.push(getTaskDetails(task));
+        });
+      }
+      if (selectedProjects.length > 0) {
+        selectedProjects.forEach(project => {
+          items.push(getProjectDetails(project));
+        });
+      }
+      
+      // If no selection, get some available tasks
+      if (items.length === 0) {
+        const availableTasks = flattenedTasks.filter(task => 
+          task.taskStatus === Task.Status.Available && !task.completed
+        );
+        availableTasks.slice(0, 100).forEach(task => {
+          items.push(getTaskDetails(task));
+        });
+      }
+    }
+    
+    return JSON.stringify({
+      success: true,
+      perspectiveName: perspectiveName,
+      items: items.slice(0, 100) // Limit to 100 items by default
+    });
+    
+  } catch (error) {
+    return JSON.stringify({
+      success: false,
+      error: error.toString()
+    });
+  }
+})()

package/dist/utils/omnifocusScripts/listPerspectives.js

@@ -0,0 +1,59 @@
+// OmniJS script to list available perspectives in OmniFocus
+(() => {
+  try {
+    const perspectives = [];
+    
+    // Get all built-in perspectives
+    // According to the API: Perspective.BuiltIn has these properties
+    const builtInPerspectives = [
+      { obj: Perspective.BuiltIn.Inbox, name: 'Inbox' },
+      { obj: Perspective.BuiltIn.Projects, name: 'Projects' },
+      { obj: Perspective.BuiltIn.Tags, name: 'Tags' },
+      { obj: Perspective.BuiltIn.Forecast, name: 'Forecast' },
+      { obj: Perspective.BuiltIn.Flagged, name: 'Flagged' },
+      { obj: Perspective.BuiltIn.Review, name: 'Review' }
+    ];
+    
+    // Add built-in perspectives
+    builtInPerspectives.forEach(p => {
+      perspectives.push({
+        id: 'builtin_' + p.name.toLowerCase(),
+        name: p.name,
+        type: 'builtin',
+        isBuiltIn: true,
+        canModify: false
+      });
+    });
+    
+    // Get all custom perspectives
+    // According to the API: Perspective.Custom.all returns all custom perspectives
+    try {
+      const customPerspectives = Perspective.Custom.all;
+      if (customPerspectives && customPerspectives.length > 0) {
+        customPerspectives.forEach(p => {
+          perspectives.push({
+            id: p.identifier || 'custom_' + p.name.toLowerCase().replace(/\s+/g, '_'),
+            name: p.name,
+            type: 'custom',
+            isBuiltIn: false,
+            canModify: true
+          });
+        });
+      }
+    } catch (e) {
+      // Custom perspectives might not be available (Standard edition)
+      // This is not a fatal error
+    }
+    
+    return JSON.stringify({
+      success: true,
+      perspectives: perspectives
+    });
+    
+  } catch (error) {
+    return JSON.stringify({
+      success: false,
+      error: error.toString()
+    });
+  }
+})()

package/dist/utils/omnifocusScripts/omnifocusDump.js

@@ -0,0 +1,223 @@
+  // OmniJS script to export active tasks from OmniFocus database - Optimized
+  (() => {
+      try {
+        const startTime = new Date();
+
+        // Helper function to format dates consistently or return null
+        function formatDate(date) {
+          if (!date) return null;
+          return date.toISOString();
+        }
+
+        // Helper function to safely get enum values - Simplified with direct mapping
+        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"
+        };
+
+        const folderStatusMap = {
+          [Folder.Status.Active]: "Active",
+          [Folder.Status.Dropped]: "Dropped"
+        };
+
+        function getEnumValue(enumObj, mapObj) {
+          if (enumObj === null || enumObj === undefined) return null;
+          return mapObj[enumObj] || "Unknown";
+        }
+
+        // Create database export object using Maps for faster lookups
+        const exportData = {
+          exportDate: new Date().toISOString(),
+          tasks: [],
+          projects: {},
+          folders: {},
+          tags: {}
+        };
+
+        // Filter active projects first to avoid unnecessary processing
+        const activeProjects = flattenedProjects.filter(project =>
+          project.status !== Project.Status.Done &&
+          project.status !== Project.Status.Dropped
+        );
+
+        // Pre-filter active tasks to avoid repeated filtering
+        const activeTasks = flattenedTasks.filter(task =>
+          task.taskStatus !== Task.Status.Completed &&
+          task.taskStatus !== Task.Status.Dropped
+        );
+
+        // Pre-filter active folders
+        const activeFolders = flattenedFolders.filter(folder =>
+          folder.status !== Folder.Status.Dropped
+        );
+
+        // Pre-filter active tags
+        const activeTags = flattenedTags.filter(tag => tag.active);
+
+        // Process projects in a single pass and store in Map for O(1) lookups
+        const projectsMap = new Map();
+        activeProjects.forEach(project => {
+          try {
+            const projectId = project.id.primaryKey;
+            const projectData = {
+              id: projectId,
+              name: project.name,
+              status: getEnumValue(project.status, projectStatusMap),
+              folderID: project.parentFolder ? project.parentFolder.id.primaryKey : null,
+              sequential: project.task.sequential || false,
+              effectiveDueDate: formatDate(project.effectiveDueDate),
+              effectiveDeferDate: formatDate(project.effectiveDeferDate),
+              dueDate: formatDate(project.dueDate),
+              deferDate: formatDate(project.deferDate),
+              completedByChildren: project.completedByChildren,
+              containsSingletonActions: project.containsSingletonActions,
+              note: project.note || "",
+              tasks: [] // Will be populated in the task loop
+            };
+            projectsMap.set(projectId, projectData);
+            exportData.projects[projectId] = projectData;
+          } catch (projectError) {
+            // Silently handle project processing errors
+          }
+        });
+
+        // Process folders in a single pass
+        const foldersMap = new Map();
+        activeFolders.forEach(folder => {
+          try {
+            const folderId = folder.id.primaryKey;
+            const folderData = {
+              id: folderId,
+              name: folder.name,
+              parentFolderID: folder.parent ? folder.parent.id.primaryKey : null,
+              status: getEnumValue(folder.status, folderStatusMap),
+              projects: [],
+              subfolders: []
+            };
+            foldersMap.set(folderId, folderData);
+            exportData.folders[folderId] = folderData;
+          } catch (folderError) {
+            // Silently handle folder processing errors
+          }
+        });
+
+        // Process tags in a single pass
+        const tagsMap = new Map();
+        activeTags.forEach(tag => {
+          try {
+            const tagId = tag.id.primaryKey;
+            const tagData = {
+              id: tagId,
+              name: tag.name,
+              parentTagID: tag.parent ? tag.parent.id.primaryKey : null,
+              active: tag.active,
+              allowsNextAction: tag.allowsNextAction,
+              tasks: []
+            };
+            tagsMap.set(tagId, tagData);
+            exportData.tags[tagId] = tagData;
+          } catch (tagError) {
+            // Silently handle tag processing errors
+          }
+        });
+
+        console.log("Building relationships and processing tasks simultaneously...");
+
+        // Build folder relationships and project-folder relationships as we go
+        foldersMap.forEach((folder, folderId) => {
+          if (folder.parentFolderID && foldersMap.has(folder.parentFolderID)) {
+            const parentFolder = foldersMap.get(folder.parentFolderID);
+            if (!parentFolder.subfolders.includes(folder.id)) {
+              parentFolder.subfolders.push(folder.id);
+            }
+          }
+        });
+
+        console.log(`Processing ${activeTasks.length} active tasks...`);
+
+        // Process tasks with an optimized approach
+        // Process in batches of 100 to prevent UI freezing
+        const BATCH_SIZE = 100;
+
+        for (let i = 0; i < activeTasks.length; i += BATCH_SIZE) {
+          const taskBatch = activeTasks.slice(i, i + BATCH_SIZE);
+
+          taskBatch.forEach(task => {
+            try {
+              // Get task data with minimal processing
+              const taskTags = task.tags.map(tag => tag.id.primaryKey);
+              const projectID = task.containingProject ? task.containingProject.id.primaryKey : null;
+
+              const taskData = {
+                id: task.id.primaryKey,
+                name: task.name,
+                note: task.note || "",
+                taskStatus: getEnumValue(task.taskStatus, taskStatusMap),
+                flagged: task.flagged,
+                dueDate: formatDate(task.dueDate),
+                deferDate: formatDate(task.deferDate),
+                effectiveDueDate: formatDate(task.effectiveDueDate),
+                effectiveDeferDate: formatDate(task.effectiveDeferDate),
+                estimatedMinutes: task.estimatedMinutes,
+                completedByChildren: task.completedByChildren,
+                sequential: task.sequential || false,
+                tags: taskTags,
+                projectID: projectID,
+                parentTaskID: task.parent ? task.parent.id.primaryKey : null,
+                children: task.children.map(child => child.id.primaryKey),
+                inInbox: task.inInbox
+              };
+
+              // Add task to export
+              exportData.tasks.push(taskData);
+
+              // Add task ID to associated project (if it exists)
+              if (projectID && projectsMap.has(projectID)) {
+                projectsMap.get(projectID).tasks.push(taskData.id);
+
+                // Update folder-project relationship (only once per project)
+                const project = projectsMap.get(projectID);
+                if (project.folderID && foldersMap.has(project.folderID)) {
+                  const folder = foldersMap.get(project.folderID);
+                  if (!folder.projects.includes(project.id)) {
+                    folder.projects.push(project.id);
+                  }
+                }
+              }
+
+              // Add task ID to associated tags
+              taskTags.forEach(tagID => {
+                if (tagsMap.has(tagID)) {
+                  tagsMap.get(tagID).tasks.push(taskData.id);
+                }
+              });
+            } catch (taskError) {
+              // Silently handle task processing errors
+            }
+          });
+        }
+
+        // Return the complete database export
+        const jsonData = JSON.stringify(exportData);
+        return jsonData;
+
+      } catch (error) {
+        return JSON.stringify({
+          success: false,
+          error: `Error exporting database: ${error}`
+        });
+      }
+    }
+  )();