@iflow-mcp/omnifocus-mcp 1.2.3

package/src/tools/primitives/removeItem.ts

@@ -0,0 +1,195 @@
+import { exec } from 'child_process';
+import { promisify } from 'util';
+const execAsync = promisify(exec);
+
+// Interface for item removal parameters
+export interface RemoveItemParams {
+  id?: string;          // ID of the task or project to remove
+  name?: string;        // Name of the task or project to remove (as fallback if ID not provided)
+  itemType: 'task' | 'project'; // Type of item to remove
+}
+
+/**
+ * Generate pure AppleScript for item removal
+ */
+function generateAppleScript(params: RemoveItemParams): string {
+  // 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: RemoveItemParams): Promise<{success: boolean, id?: string, name?: string, error?: string}> {
+  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: any) {
+    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/src/types.ts

@@ -0,0 +1,107 @@
+export interface OmnifocusTask {
+    id: string;
+    name: string;
+    note: string;
+    flagged: boolean;
+    
+    // Status
+    completed: boolean;
+    completionDate: string | null;
+    dropDate: string | null;
+    taskStatus: string; // One of Task.Status values
+    active: boolean;
+    
+    // Dates
+    dueDate: string | null;
+    deferDate: string | null;
+    estimatedMinutes: number | null;
+    
+    // Organization
+    tags: string[]; // Tag IDs
+    tagNames: string[]; // Human-readable tag names
+    parentId: string | null;
+    containingProjectId: string | null;
+    projectId: string | null;
+    
+    // Task relationships
+    childIds: string[];
+    hasChildren: boolean;
+    sequential: boolean;
+    completedByChildren: boolean;
+    
+    // Recurring task information
+    repetitionRule: string | null; // Textual representation of repetition rule
+    isRepeating: boolean;
+    repetitionMethod: string | null; // Fixed or due-based repetition
+    
+    // Attachments
+    attachments: any[]; // FileWrapper representations
+    linkedFileURLs: string[];
+    
+    // Notifications
+    notifications: any[]; // Task.Notification representations
+    
+    // Settings
+    shouldUseFloatingTimeZone: boolean;
+  }
+
+export interface OmnifocusDatabase {
+  exportDate: string;
+  tasks: OmnifocusTask[];
+  projects: Record<string, OmnifocusProject>;
+  folders: Record<string, OmnifocusFolder>;
+  tags: Record<string, OmnifocusTag>;
+}
+
+export interface OmnifocusProject {
+  id: string;
+  name: string;
+  status: string;
+  folderID: string | null;
+  sequential: boolean;
+  effectiveDueDate: string | null;
+  effectiveDeferDate: string | null;
+  dueDate: string | null;
+  deferDate: string | null;
+  completedByChildren: boolean;
+  containsSingletonActions: boolean;
+  note: string;
+  tasks: string[]; // Task IDs
+  flagged?: boolean;
+  estimatedMinutes?: number | null;
+}
+
+export interface OmnifocusFolder {
+  id: string;
+  name: string;
+  parentFolderID: string | null;
+  status: string;
+  projects: string[]; // Project IDs
+  subfolders: string[]; // Subfolder IDs
+}
+
+export interface OmnifocusTag {
+  id: string;
+  name: string;
+  parentTagID: string | null;
+  active: boolean;
+  allowsNextAction: boolean;
+  tasks: string[]; // Task IDs
+}
+
+export interface OmnifocusPerspective {
+  id: string;
+  name: string;
+  type: 'builtin' | 'custom';
+  isBuiltIn: boolean;
+  canModify: boolean; // false for built-in perspectives
+  // Filter rules for custom perspectives (if applicable)
+  filterRules?: {
+    availability?: string[];
+    tags?: string[];
+    projects?: string[];
+    flagged?: boolean;
+    dueWithin?: number;
+    // Additional filter properties as needed
+  };
+}

package/src/utils/cacheManager.ts

@@ -0,0 +1,234 @@
+import { OmnifocusDatabase } from '../types.js';
+import { executeOmniFocusScript } from './scriptExecution.js';
+
+interface CacheEntry {
+  data: OmnifocusDatabase;
+  timestamp: Date;
+  checksum?: string;
+}
+
+interface CacheOptions {
+  ttlSeconds?: number;  // Time to live in seconds
+  maxSize?: number;     // Maximum cache size in MB
+  useChecksum?: boolean; // Whether to use checksum for validation
+}
+
+class OmniFocusCacheManager {
+  private cache: Map<string, CacheEntry> = new Map();
+  private options: Required<CacheOptions>;
+  private totalSize: number = 0;
+  
+  constructor(options: CacheOptions = {}) {
+    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: string): Promise<OmnifocusDatabase | null> {
+    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: string, data: OmnifocusDatabase): Promise<void> {
+    // 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: string): void {
+    this.cache.delete(key);
+  }
+  
+  /**
+   * Clear all cache entries
+   */
+  clear(): void {
+    this.cache.clear();
+    this.totalSize = 0;
+  }
+  
+  /**
+   * Get cache statistics
+   */
+  getStats(): {
+    entries: number;
+    sizeEstimateMB: number;
+    oldestEntry: Date | null;
+    hitRate: number;
+  } {
+    let oldestEntry: Date | null = 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
+   */
+  private async getDatabaseChecksum(): Promise<string> {
+    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
+   */
+  private evictOldest(): void {
+    let oldestKey: string | null = 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
+  private hits = 0;
+  private misses = 0;
+  
+  private calculateHitRate(): number {
+    const total = this.hits + this.misses;
+    if (total === 0) return 0;
+    return (this.hits / total) * 100;
+  }
+  
+  trackHit(): void {
+    this.hits++;
+  }
+  
+  trackMiss(): void {
+    this.misses++;
+  }
+}
+
+// Singleton instance
+let cacheManager: OmniFocusCacheManager | null = null;
+
+/**
+ * Get or create the cache manager instance
+ */
+export function getCacheManager(options?: CacheOptions): OmniFocusCacheManager {
+  if (!cacheManager) {
+    cacheManager = new OmniFocusCacheManager(options);
+  }
+  return cacheManager;
+}
+
+/**
+ * Reset the cache manager (useful for testing)
+ */
+export function resetCacheManager(): void {
+  if (cacheManager) {
+    cacheManager.clear();
+  }
+  cacheManager = null;
+}

package/src/utils/dateFormatting.ts

@@ -0,0 +1,81 @@
+/**
+ * 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: string, varName: string): string {
+  // 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 the complete AppleScript for date assignments
+ * Returns both the pre-tell block code and the in-tell block assignment
+ */
+export interface DateAssignmentParts {
+  preScript: string;  // Code to run before tell blocks
+  assignmentScript: string; // Code to run inside tell blocks
+}
+
+/**
+ * Generate date assignment that works with AppleScript restrictions
+ */
+export function generateDateAssignmentV2(
+  objectName: string,
+  propertyName: string,
+  isoDateString: string | undefined
+): DateAssignmentParts | null {
+  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
+  };
+}