@iflow-mcp/omnifocus-mcp 1.2.3

package/src/tools/dumpDatabaseOptimized.ts

@@ -0,0 +1,231 @@
+import { OmnifocusDatabase } from '../types.js';
+import { executeOmniFocusScript } from '../utils/scriptExecution.js';
+import { getCacheManager } from '../utils/cacheManager.js';
+import { dumpDatabase as originalDumpDatabase } from './dumpDatabase.js';
+
+/**
+ * Optimized version of dumpDatabase that uses caching
+ * Falls back to original implementation if caching fails
+ */
+export async function dumpDatabaseOptimized(options?: {
+  forceRefresh?: boolean;
+  cacheKey?: string;
+}): Promise<OmnifocusDatabase> {
+  const cacheManager = getCacheManager({
+    ttlSeconds: 300, // 5 minute cache
+    useChecksum: true // Validate with database checksum
+  });
+  
+  const cacheKey = options?.cacheKey || 'full-dump';
+  
+  // Check if we should force a refresh
+  if (!options?.forceRefresh) {
+    const cached = await cacheManager.get(cacheKey);
+    if (cached) {
+      cacheManager.trackHit();
+      console.log(`Cache hit for ${cacheKey}. Stats:`, cacheManager.getStats());
+      return cached;
+    }
+  }
+  
+  cacheManager.trackMiss();
+  console.log(`Cache miss for ${cacheKey}. Fetching fresh data...`);
+  
+  // Fetch fresh data using the original implementation
+  const freshData = await originalDumpDatabase();
+  
+  // Store in cache for next time
+  await cacheManager.set(cacheKey, freshData);
+  
+  return freshData;
+}
+
+/**
+ * Get just database statistics without full dump
+ * Much more efficient for overview information
+ */
+export async function getDatabaseStats(): Promise<{
+  taskCount: number;
+  activeTaskCount: number;
+  projectCount: number;
+  activeProjectCount: number;
+  folderCount: number;
+  tagCount: number;
+  overdueCount: number;
+  nextActionCount: number;
+  flaggedCount: number;
+  inboxCount: number;
+  lastModified: string;
+}> {
+  const script = `
+    (() => {
+      try {
+        // Calculate statistics without fetching full data
+        const allTasks = flattenedTasks;
+        const activeTasks = allTasks.filter(task => 
+          task.taskStatus !== Task.Status.Completed && 
+          task.taskStatus !== Task.Status.Dropped
+        );
+        
+        const allProjects = flattenedProjects;
+        const activeProjects = allProjects.filter(project =>
+          project.status === Project.Status.Active
+        );
+        
+        // Count specific task statuses
+        const overdueCount = activeTasks.filter(task => 
+          task.taskStatus === Task.Status.Overdue
+        ).length;
+        
+        const nextActionCount = activeTasks.filter(task => 
+          task.taskStatus === Task.Status.Next
+        ).length;
+        
+        const flaggedCount = activeTasks.filter(task => task.flagged).length;
+        
+        const inboxCount = activeTasks.filter(task => task.inInbox).length;
+        
+        // Get latest modification time
+        let lastModified = new Date(0);
+        allTasks.forEach(task => {
+          if (task.modificationDate && task.modificationDate > lastModified) {
+            lastModified = task.modificationDate;
+          }
+        });
+        
+        return JSON.stringify({
+          taskCount: allTasks.length,
+          activeTaskCount: activeTasks.length,
+          projectCount: allProjects.length,
+          activeProjectCount: activeProjects.length,
+          folderCount: flattenedFolders.length,
+          tagCount: flattenedTags.filter(tag => tag.active).length,
+          overdueCount: overdueCount,
+          nextActionCount: nextActionCount,
+          flaggedCount: flaggedCount,
+          inboxCount: inboxCount,
+          lastModified: lastModified.toISOString()
+        });
+        
+      } catch (error) {
+        return JSON.stringify({
+          error: "Failed to get database stats: " + error.toString()
+        });
+      }
+    })();
+  `;
+  
+  // Write script to temp file and execute
+  const fs = await import('fs');
+  const tempFile = `/tmp/omnifocus_stats_${Date.now()}.js`;
+  fs.writeFileSync(tempFile, script);
+  
+  const result = await executeOmniFocusScript(tempFile);
+  fs.unlinkSync(tempFile);
+  
+  if (result.error) {
+    throw new Error(result.error);
+  }
+  
+  return result;
+}
+
+/**
+ * Get incremental changes since a specific timestamp
+ * Much more efficient for periodic updates
+ */
+export async function getChangesSince(since: Date): Promise<{
+  newTasks: any[];
+  updatedTasks: any[];
+  completedTasks: any[];
+  newProjects: any[];
+  updatedProjects: any[];
+}> {
+  const script = `
+    (() => {
+      try {
+        const sinceDate = new Date("${since.toISOString()}");
+        
+        // Find tasks that changed since the given date
+        const allTasks = flattenedTasks;
+        
+        const newTasks = allTasks.filter(task => 
+          task.creationDate && task.creationDate > sinceDate
+        ).map(task => ({
+          id: task.id.primaryKey,
+          name: task.name,
+          creationDate: task.creationDate.toISOString()
+        }));
+        
+        const updatedTasks = allTasks.filter(task => 
+          task.modificationDate && 
+          task.modificationDate > sinceDate &&
+          task.creationDate && 
+          task.creationDate <= sinceDate
+        ).map(task => ({
+          id: task.id.primaryKey,
+          name: task.name,
+          modificationDate: task.modificationDate.toISOString()
+        }));
+        
+        const completedTasks = allTasks.filter(task =>
+          task.completionDate &&
+          task.completionDate > sinceDate
+        ).map(task => ({
+          id: task.id.primaryKey,
+          name: task.name,
+          completionDate: task.completionDate.toISOString()
+        }));
+        
+        // Find projects that changed
+        const allProjects = flattenedProjects;
+        
+        const newProjects = allProjects.filter(project =>
+          project.creationDate && project.creationDate > sinceDate
+        ).map(project => ({
+          id: project.id.primaryKey,
+          name: project.name,
+          creationDate: project.creationDate.toISOString()
+        }));
+        
+        const updatedProjects = allProjects.filter(project =>
+          project.modificationDate &&
+          project.modificationDate > sinceDate &&
+          project.creationDate &&
+          project.creationDate <= sinceDate
+        ).map(project => ({
+          id: project.id.primaryKey,
+          name: project.name,
+          modificationDate: project.modificationDate.toISOString()
+        }));
+        
+        return JSON.stringify({
+          newTasks: newTasks,
+          updatedTasks: updatedTasks,
+          completedTasks: completedTasks,
+          newProjects: newProjects,
+          updatedProjects: updatedProjects
+        });
+        
+      } catch (error) {
+        return JSON.stringify({
+          error: "Failed to get changes: " + error.toString()
+        });
+      }
+    })();
+  `;
+  
+  // Write script to temp file and execute
+  const fs = await import('fs');
+  const tempFile = `/tmp/omnifocus_changes_${Date.now()}.js`;
+  fs.writeFileSync(tempFile, script);
+  
+  const result = await executeOmniFocusScript(tempFile);
+  fs.unlinkSync(tempFile);
+  
+  if (result.error) {
+    throw new Error(result.error);
+  }
+  
+  return result;
+}

package/src/tools/primitives/addOmniFocusTask.ts

@@ -0,0 +1,252 @@
+import { exec } from 'child_process';
+import { promisify } from 'util';
+import { writeFileSync, unlinkSync } from 'fs';
+import { tmpdir } from 'os';
+import { join } from 'path';
+import { createDateOutsideTellBlock } from '../../utils/dateFormatting.js';
+const execAsync = promisify(exec);
+
+// Interface for task creation parameters
+export interface AddOmniFocusTaskParams {
+  name: string;
+  note?: string;
+  dueDate?: string; // ISO date string
+  deferDate?: string; // ISO date string
+  flagged?: boolean;
+  estimatedMinutes?: number;
+  tags?: string[]; // Tag names
+  projectName?: string; // Project name to add task to
+  // Hierarchy support
+  parentTaskId?: string;
+  parentTaskName?: string;
+  hierarchyLevel?: number; // ignored for single add
+}
+
+/**
+ * Generate pure AppleScript for task creation
+ */
+function generateAppleScript(params: AddOmniFocusTaskParams): string {
+  // 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, '\\$&') || '';
+  
+  // Generate date constructions outside tell blocks
+  let datePreScript = '';
+  let dueDateVar = '';
+  let deferDateVar = '';
+  
+  if (dueDate) {
+    dueDateVar = `dueDate${Math.random().toString(36).substr(2, 9)}`;
+    datePreScript += createDateOutsideTellBlock(dueDate, dueDateVar) + '\n\n';
+  }
+  
+  if (deferDate) {
+    deferDateVar = `deferDate${Math.random().toString(36).substr(2, 9)}`;
+    datePreScript += createDateOutsideTellBlock(deferDate, deferDateVar) + '\n\n';
+  }
+  
+  // Construct AppleScript with error handling
+  let script = datePreScript + `
+  try
+    tell application "OmniFocus"
+      tell front document
+        -- Resolve parent task if provided
+        set newTask to missing value
+        set parentTask to missing value
+        set placement to ""
+
+        if "${parentTaskId}" is not "" then
+          try
+            set parentTask to first flattened task where id = "${parentTaskId}"
+          end try
+          if parentTask is missing value then
+            try
+              set parentTask to first inbox task where id = "${parentTaskId}"
+            end try
+          end if
+          -- If projectName provided, ensure parent is within that project
+          if parentTask is not missing value and "${projectName}" is not "" then
+            try
+              set pproj to containing project of parentTask
+              if pproj is missing value or name of pproj is not "${projectName}" then set parentTask to missing value
+            end try
+          end if
+        end if
+
+        if parentTask is missing value and "${parentTaskName}" is not "" then
+          if "${projectName}" is not "" then
+            -- Find by name but constrain to the specified project
+            try
+              set parentTask to first flattened task where name = "${parentTaskName}"
+            end try
+            if parentTask is not missing value then
+              try
+                set pproj to containing project of parentTask
+                if pproj is missing value or name of pproj is not "${projectName}" then set parentTask to missing value
+              end try
+            end if
+          else
+            -- No project specified; allow global or inbox match by name
+            try
+              set parentTask to first flattened task where name = "${parentTaskName}"
+            end try
+            if parentTask is missing value then
+              try
+                set parentTask to first inbox task where name = "${parentTaskName}"
+              end try
+            end if
+          end if
+        end if
+
+        if parentTask is not missing value then
+          -- Create task under parent task
+          set newTask to make new task with properties {name:"${name}"} at end of tasks of parentTask
+        else if "${projectName}" is not "" then
+          -- Create under 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
+          -- Fallback to inbox
+          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
+          set due date of newTask to ` + dueDateVar : ''}
+        ${deferDate ? `
+          -- Set defer date
+          set defer date of newTask to ` + deferDateVar : ''}
+        ${flagged ? `set flagged of newTask to true` : ''}
+        ${estimatedMinutes ? `set estimated minutes of newTask to ${estimatedMinutes}` : ''}
+        
+        -- Derive placement from container; distinguish real parent vs project root task
+        try
+          set placement to "inbox"
+          set ctr to container of newTask
+          set cclass to class of ctr as string
+          set ctrId to id of ctr as string
+          if cclass is "project" then
+            set placement to "project"
+          else if cclass is "task" then
+            if parentTask is not missing value then
+              set parentId to id of parentTask as string
+              if ctrId is equal to parentId then
+                set placement to "parent"
+              else
+                -- Likely the project's root task; treat as project
+                set placement to "project"
+              end if
+            else
+              -- No explicit parent requested; container is root task -> treat as project
+              set placement to "project"
+            end if
+          else
+            set placement to "inbox"
+          end if
+        on error
+          -- If container access fails (e.g., inbox), default based on projectName
+          if "${projectName}" is not "" then
+            set placement to "project"
+          else
+            set placement to "inbox"
+          end if
+        end try
+
+        -- 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}"
+            add theTag to tags of newTask
+          on error
+            -- Tag might not exist, try to create it
+            try
+              set theTag to make new tag with properties {name:"${sanitizedTag}"}
+              add theTag to tags of newTask
+            on error
+              -- Could not create or add tag
+            end try
+          end try`;
+        }).join('\n') : ''}
+        
+        -- Return success with task ID and placement
+        return "{\\\"success\\\":true,\\\"taskId\\\":\\"" & taskId & "\\",\\\"name\\\":\\"${name}\\\",\\\"placement\\\":\\"" & placement & "\\"}"
+      end tell
+    end tell
+  on error errorMessage
+    return "{\\\"success\\\":false,\\\"error\\\":\\"" & errorMessage & "\\"}"
+  end try
+  `;
+  
+  return script;
+}
+
+/**
+ * Add a task to OmniFocus
+ */
+export async function addOmniFocusTask(params: AddOmniFocusTaskParams): Promise<{success: boolean, taskId?: string, error?: string, placement?: 'parent' | 'project' | 'inbox'}> {
+  try {
+    // Generate AppleScript
+    const script = generateAppleScript(params);
+    console.error("Executing AppleScript via temp file...");
+
+    // Write to a temporary AppleScript file to avoid shell escaping issues
+    const tempFile = join(tmpdir(), `omnifocus_add_${Date.now()}.applescript`);
+    writeFileSync(tempFile, script, { encoding: 'utf8' });
+
+    // Execute AppleScript from file
+    const { stdout, stderr } = await execAsync(`osascript ${tempFile}`);
+
+    if (stderr) {
+      console.error("AppleScript stderr:", stderr);
+    }
+    
+    console.error("AppleScript stdout:", stdout);
+    
+    // Cleanup temp file
+    try { unlinkSync(tempFile); } catch {}
+    
+    // Parse the result
+    try {
+      const result = JSON.parse(stdout);
+      
+      // Return the result
+      return {
+        success: result.success,
+        taskId: result.taskId,
+        error: result.error,
+        placement: result.placement
+      };
+    } 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 addOmniFocusTask:", error);
+    return {
+      success: false,
+      error: error?.message || "Unknown error in addOmniFocusTask"
+    };
+  }
+} 

package/src/tools/primitives/addProject.ts

@@ -0,0 +1,156 @@
+import { exec } from 'child_process';
+import { promisify } from 'util';
+import { createDateOutsideTellBlock } from '../../utils/dateFormatting.js';
+const execAsync = promisify(exec);
+
+// Interface for project creation parameters
+export interface AddProjectParams {
+  name: string;
+  note?: string;
+  dueDate?: string; // ISO date string
+  deferDate?: string; // ISO date string
+  flagged?: boolean;
+  estimatedMinutes?: number;
+  tags?: string[]; // Tag names
+  folderName?: string; // Folder name to add project to
+  sequential?: boolean; // Whether tasks should be sequential or parallel
+}
+
+/**
+ * Generate pure AppleScript for project creation
+ */
+function generateAppleScript(params: AddProjectParams): string {
+  // 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;
+  
+  // Generate date constructions outside tell blocks
+  let datePreScript = '';
+  let dueDateVar = '';
+  let deferDateVar = '';
+  
+  if (dueDate) {
+    dueDateVar = `dueDate${Math.random().toString(36).substr(2, 9)}`;
+    datePreScript += createDateOutsideTellBlock(dueDate, dueDateVar) + '\n\n';
+  }
+  
+  if (deferDate) {
+    deferDateVar = `deferDate${Math.random().toString(36).substr(2, 9)}`;
+    datePreScript += createDateOutsideTellBlock(deferDate, deferDateVar) + '\n\n';
+  }
+  
+  // Construct AppleScript with error handling
+  let script = datePreScript + `
+  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
+          set due date of newProject to ` + dueDateVar : ''}
+        ${deferDate ? `
+          -- Set defer date
+          set defer date of newProject to ` + deferDateVar : ''}
+        ${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}"
+            add theTag to tags of newProject
+          on error
+            -- Tag might not exist, try to create it
+            try
+              set theTag to make new tag with properties {name:"${sanitizedTag}"}
+              add theTag to tags of newProject
+            on error
+              -- Could not create or add tag
+            end try
+          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: AddProjectParams): Promise<{success: boolean, projectId?: string, error?: string}> {
+  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: any) {
+    console.error("Error in addProject:", error);
+    return {
+      success: false,
+      error: error?.message || "Unknown error in addProject"
+    };
+  }
+}