@iflow-mcp/omnifocus-mcp 1.2.3

package/src/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/src/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/src/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}`
+        });
+      }
+    }
+  )();

package/src/utils/scriptExecution.ts

@@ -0,0 +1,128 @@
+import { exec } from 'child_process';
+import { promisify } from 'util';
+import { writeFileSync, unlinkSync, readFileSync } from 'fs';
+import { join } from 'path';
+import { tmpdir } from 'os';
+import { fileURLToPath } from 'url';
+import { dirname } from 'path';
+import { existsSync } from 'fs';
+
+const execAsync = promisify(exec);
+
+// Helper function to execute OmniFocus scripts
+export async function executeJXA(script: string): Promise<any[]> {
+  try {
+    // Write the script to a temporary file in the system temp directory
+    const tempFile = join(tmpdir(), `jxa_script_${Date.now()}.js`);
+    
+    // Write the script to the temporary file
+    writeFileSync(tempFile, script);
+    
+    // Execute the script using osascript
+    const { stdout, stderr } = await execAsync(`osascript -l JavaScript ${tempFile}`);
+    
+    if (stderr) {
+      console.error("Script stderr output:", stderr);
+    }
+    
+    // Clean up the temporary file
+    unlinkSync(tempFile);
+    
+    // Parse the output as JSON
+    try {
+      const result = JSON.parse(stdout);
+      return result;
+    } catch (e) {
+      console.error("Failed to parse script output as JSON:", e);
+      
+      // If this contains a "Found X tasks" message, treat it as a successful non-JSON response
+      if (stdout.includes("Found") && stdout.includes("tasks")) {
+        return [];
+      }
+      
+      return [];
+    }
+  } catch (error) {
+    console.error("Failed to execute JXA script:", error);
+    throw error;
+  }
+}
+
+// Function to execute scripts in OmniFocus using the URL scheme
+// Update src/utils/scriptExecution.ts
+export async function executeOmniFocusScript(scriptPath: string, args?: any): Promise<any> {
+  try {
+    // Get the actual script path (existing code remains the same)
+    let actualPath;
+    if (scriptPath.startsWith('@')) {
+      const scriptName = scriptPath.substring(1);
+      const __filename = fileURLToPath(import.meta.url);
+      const __dirname = dirname(__filename);
+      
+      const distPath = join(__dirname, '..', 'utils', 'omnifocusScripts', scriptName);
+      const srcPath = join(__dirname, '..', '..', 'src', 'utils', 'omnifocusScripts', scriptName);
+      
+      if (existsSync(distPath)) {
+        actualPath = distPath;
+      } else if (existsSync(srcPath)) {
+        actualPath = srcPath;
+      } else {
+        actualPath = join(__dirname, '..', 'omnifocusScripts', scriptName);
+      }
+    } else {
+      actualPath = scriptPath;
+    }
+    
+    // Read the script file
+    const scriptContent = readFileSync(actualPath, 'utf8');
+    
+    // Create a temporary file for our JXA wrapper script
+    const tempFile = join(tmpdir(), `jxa_wrapper_${Date.now()}.js`);
+    
+    // Escape the script content properly for use in JXA
+    const escapedScript = scriptContent.replace(/\\/g, '\\\\').replace(/`/g, '\\`').replace(/\$/g, '\\$');
+    
+    // Create a JXA script that will execute our OmniJS script in OmniFocus
+    const jxaScript = `
+    function run() {
+      try {
+        const app = Application('OmniFocus');
+        app.includeStandardAdditions = true;
+        
+        // Run the OmniJS script in OmniFocus and capture the output
+        const result = app.evaluateJavascript(\`${escapedScript}\`);
+        
+        // Return the result
+        return result;
+      } catch (e) {
+        return JSON.stringify({ error: e.message });
+      }
+    }
+    `;
+    
+    // Write the JXA script to the temporary file
+    writeFileSync(tempFile, jxaScript);
+    
+    // Execute the JXA script using osascript
+    const { stdout, stderr } = await execAsync(`osascript -l JavaScript ${tempFile}`);
+    
+    // Clean up the temporary file
+    unlinkSync(tempFile);
+    
+    if (stderr) {
+      console.error("Script stderr output:", stderr);
+    }
+    
+    // Parse the output as JSON
+    try {
+      return JSON.parse(stdout);
+    } catch (parseError) {
+      console.error("Error parsing script output:", parseError);
+      return stdout;
+    }
+  } catch (error) {
+    console.error("Failed to execute OmniFocus script:", error);
+    throw error;
+  }
+}
+    

package/tsconfig.json

@@ -0,0 +1,15 @@
+{
+  "compilerOptions": {
+    "target": "ES2022",
+    "module": "ES2022",
+    "moduleResolution": "node",
+    "esModuleInterop": true,
+    "strict": true,
+    "skipLibCheck": true,
+    "forceConsistentCasingInFileNames": true,
+    "outDir": "dist",
+    "rootDir": "src"
+  },
+  "include": ["src/**/*"],
+  "exclude": ["node_modules", "dist"]
+}