@iflow-mcp/omnifocus-mcp 1.2.3

package/dist/tools/definitions/queryOmnifocus.js

@@ -0,0 +1,190 @@
+import { z } from 'zod';
+import { queryOmnifocus } from '../primitives/queryOmnifocus.js';
+export const schema = z.object({
+    entity: z.enum(['tasks', 'projects', 'folders']).describe("Type of entity to query. Choose 'tasks' for individual tasks, 'projects' for projects, or 'folders' for folder organization"),
+    filters: z.object({
+        projectId: z.string().optional().describe("Filter tasks by exact project ID (use when you know the specific project ID)"),
+        projectName: z.string().optional().describe("Filter tasks by project name. CASE-INSENSITIVE PARTIAL MATCHING - 'review' matches 'Weekly Review', 'Review Documents', etc. Special value: 'inbox' returns inbox tasks"),
+        folderId: z.string().optional().describe("Filter projects by exact folder ID (use when you know the specific folder ID)"),
+        tags: z.array(z.string()).optional().describe("Filter by tag names. EXACT MATCH, CASE-SENSITIVE. OR logic - items must have at least ONE of the specified tags. Example: ['Work'] and ['work'] are different"),
+        status: z.array(z.string()).optional().describe("Filter by status (OR logic - matches any). TASKS: 'Next' (next action), 'Available' (ready to work), 'Blocked' (waiting), 'DueSoon' (due <24h), 'Overdue' (past due), 'Completed', 'Dropped'. PROJECTS: 'Active', 'OnHold', 'Done', 'Dropped'"),
+        flagged: z.boolean().optional().describe("Filter by flagged status. true = only flagged items, false = only unflagged items"),
+        dueWithin: z.number().optional().describe("Returns items due from TODAY through N days in future. Example: 7 = items due within next week (today + 6 days)"),
+        deferredUntil: z.number().optional().describe("Returns items CURRENTLY DEFERRED that will become available within N days. Example: 3 = items becoming available in next 3 days"),
+        hasNote: z.boolean().optional().describe("Filter by note presence. true = items with non-empty notes (whitespace ignored), false = items with no notes or only whitespace")
+    }).optional().describe("Optional filters to narrow results. ALL filters combine with AND logic (must match all). Within array filters (tags, status) OR logic applies"),
+    fields: z.array(z.string()).optional().describe("Specific fields to return (reduces response size). TASK FIELDS: id, name, note, flagged, taskStatus, dueDate, deferDate, completionDate, estimatedMinutes, tagNames, tags, projectName, projectId, parentId, childIds, hasChildren, sequential, completedByChildren, inInbox, modificationDate (or modified), creationDate (or added). PROJECT FIELDS: id, name, status, note, folderName, folderID, sequential, dueDate, deferDate, effectiveDueDate, effectiveDeferDate, completedByChildren, containsSingletonActions, taskCount, tasks, modificationDate, creationDate. FOLDER FIELDS: id, name, path, parentFolderID, status, projectCount, projects, subfolders. NOTE: Date fields use 'added' and 'modified' in OmniFocus API"),
+    limit: z.number().optional().describe("Maximum number of items to return. Useful for large result sets. Default: no limit"),
+    sortBy: z.string().optional().describe("Field to sort by. OPTIONS: name (alphabetical), dueDate (earliest first, null last), deferDate (earliest first, null last), modificationDate (most recent first), creationDate (oldest first), estimatedMinutes (shortest first), taskStatus (groups by status)"),
+    sortOrder: z.enum(['asc', 'desc']).optional().describe("Sort order. 'asc' = ascending (A-Z, old-new, small-large), 'desc' = descending (Z-A, new-old, large-small). Default: 'asc'"),
+    includeCompleted: z.boolean().optional().describe("Include completed and dropped items. Default: false (active items only)"),
+    summary: z.boolean().optional().describe("Return only count of matches, not full details. Efficient for statistics. Default: false")
+});
+export async function handler(args, extra) {
+    try {
+        // Call the queryOmniFocus function
+        const result = await queryOmnifocus(args);
+        if (result.success) {
+            // Format response based on whether it's a summary or full results
+            if (args.summary) {
+                return {
+                    content: [{
+                            type: "text",
+                            text: `Found ${result.count} ${args.entity} matching your criteria.`
+                        }]
+                };
+            }
+            else {
+                // Format the results in a compact, readable format
+                const items = result.items || [];
+                let output = formatQueryResults(items, args.entity, args.filters);
+                // Add metadata about the query
+                if (items.length === args.limit) {
+                    output += `\n\n⚠️ Results limited to ${args.limit} items. More may be available.`;
+                }
+                return {
+                    content: [{
+                            type: "text",
+                            text: output
+                        }]
+                };
+            }
+        }
+        else {
+            return {
+                content: [{
+                        type: "text",
+                        text: `Query failed: ${result.error}`
+                    }],
+                isError: true
+            };
+        }
+    }
+    catch (err) {
+        const error = err;
+        console.error(`Query execution error: ${error.message}`);
+        return {
+            content: [{
+                    type: "text",
+                    text: `Error executing query: ${error.message}`
+                }],
+            isError: true
+        };
+    }
+}
+// Helper function to format query results in a compact way
+function formatQueryResults(items, entity, filters) {
+    if (items.length === 0) {
+        return `No ${entity} found matching the specified criteria.`;
+    }
+    let output = `## Query Results: ${items.length} ${entity}\n\n`;
+    // Add filter summary if filters were applied
+    if (filters && Object.keys(filters).length > 0) {
+        output += `Filters applied: ${formatFilters(filters)}\n\n`;
+    }
+    // Format each item based on entity type
+    switch (entity) {
+        case 'tasks':
+            output += formatTasks(items);
+            break;
+        case 'projects':
+            output += formatProjects(items);
+            break;
+        case 'folders':
+            output += formatFolders(items);
+            break;
+    }
+    return output;
+}
+function formatFilters(filters) {
+    const parts = [];
+    if (filters.projectId)
+        parts.push(`projectId: "${filters.projectId}"`);
+    if (filters.projectName)
+        parts.push(`project: "${filters.projectName}"`);
+    if (filters.folderId)
+        parts.push(`folderId: "${filters.folderId}"`);
+    if (filters.tags)
+        parts.push(`tags: [${filters.tags.join(', ')}]`);
+    if (filters.status)
+        parts.push(`status: [${filters.status.join(', ')}]`);
+    if (filters.flagged !== undefined)
+        parts.push(`flagged: ${filters.flagged}`);
+    if (filters.dueWithin)
+        parts.push(`due within ${filters.dueWithin} days`);
+    if (filters.deferredUntil)
+        parts.push(`deferred becoming available within ${filters.deferredUntil} days`);
+    if (filters.hasNote !== undefined)
+        parts.push(`has note: ${filters.hasNote}`);
+    return parts.join(', ');
+}
+function formatTasks(tasks) {
+    return tasks.map(task => {
+        const parts = [];
+        // Core display
+        const flag = task.flagged ? '🚩 ' : '';
+        parts.push(`• ${flag}${task.name || 'Unnamed'}`);
+        // Add ID if present
+        if (task.id) {
+            parts.push(`[${task.id}]`);
+        }
+        // Project context
+        if (task.projectName) {
+            parts.push(`(${task.projectName})`);
+        }
+        // Dates
+        if (task.dueDate) {
+            parts.push(`[due: ${formatDate(task.dueDate)}]`);
+        }
+        if (task.deferDate) {
+            parts.push(`[defer: ${formatDate(task.deferDate)}]`);
+        }
+        // Time estimate
+        if (task.estimatedMinutes) {
+            const hours = task.estimatedMinutes >= 60
+                ? `${Math.floor(task.estimatedMinutes / 60)}h`
+                : `${task.estimatedMinutes}m`;
+            parts.push(`(${hours})`);
+        }
+        // Tags
+        if (task.tagNames?.length > 0) {
+            parts.push(`<${task.tagNames.join(',')}>`);
+        }
+        // Status
+        if (task.taskStatus) {
+            parts.push(`#${task.taskStatus.toLowerCase()}`);
+        }
+        // Metadata dates if requested
+        if (task.creationDate) {
+            parts.push(`[created: ${formatDate(task.creationDate)}]`);
+        }
+        if (task.modificationDate) {
+            parts.push(`[modified: ${formatDate(task.modificationDate)}]`);
+        }
+        if (task.completionDate) {
+            parts.push(`[completed: ${formatDate(task.completionDate)}]`);
+        }
+        return parts.join(' ');
+    }).join('\n');
+}
+function formatProjects(projects) {
+    return projects.map(project => {
+        const status = project.status !== 'Active' ? ` [${project.status}]` : '';
+        const folder = project.folderName ? ` 📁 ${project.folderName}` : '';
+        const taskCount = project.taskCount !== undefined && project.taskCount !== null ? ` (${project.taskCount} tasks)` : '';
+        const flagged = project.flagged ? '🚩 ' : '';
+        const due = project.dueDate ? ` [due: ${formatDate(project.dueDate)}]` : '';
+        return `P: ${flagged}${project.name}${status}${due}${folder}${taskCount}`;
+    }).join('\n');
+}
+function formatFolders(folders) {
+    return folders.map(folder => {
+        const projectCount = folder.projectCount !== undefined ? ` (${folder.projectCount} projects)` : '';
+        const path = folder.path ? ` 📍 ${folder.path}` : '';
+        return `F: ${folder.name}${projectCount}${path}`;
+    }).join('\n');
+}
+function formatDate(dateStr) {
+    const date = new Date(dateStr);
+    return `${date.getMonth() + 1}/${date.getDate()}`;
+}

package/dist/tools/definitions/removeItem.js

@@ -0,0 +1,80 @@
+import { z } from 'zod';
+import { removeItem } from '../primitives/removeItem.js';
+export const schema = z.object({
+    id: z.string().optional().describe("The ID of the task or project to remove"),
+    name: z.string().optional().describe("The name of the task or project to remove (as fallback if ID not provided)"),
+    itemType: z.enum(['task', 'project']).describe("Type of item to remove ('task' or 'project')")
+});
+export async function handler(args, extra) {
+    try {
+        // Validate that either id or name is provided
+        if (!args.id && !args.name) {
+            return {
+                content: [{
+                        type: "text",
+                        text: "Either id or name must be provided to remove an item."
+                    }],
+                isError: true
+            };
+        }
+        // Validate itemType
+        if (!['task', 'project'].includes(args.itemType)) {
+            return {
+                content: [{
+                        type: "text",
+                        text: `Invalid item type: ${args.itemType}. Must be either 'task' or 'project'.`
+                    }],
+                isError: true
+            };
+        }
+        // Log the remove operation for debugging
+        console.error(`Removing ${args.itemType} with ID: ${args.id || 'not provided'}, Name: ${args.name || 'not provided'}`);
+        // Call the removeItem function 
+        const result = await removeItem(args);
+        if (result.success) {
+            // Item was removed successfully
+            const itemTypeLabel = args.itemType === 'task' ? 'Task' : 'Project';
+            return {
+                content: [{
+                        type: "text",
+                        text: `✅ ${itemTypeLabel} "${result.name}" removed successfully.`
+                    }]
+            };
+        }
+        else {
+            // Item removal failed
+            let errorMsg = `Failed to remove ${args.itemType}`;
+            if (result.error) {
+                if (result.error.includes("Item not found")) {
+                    errorMsg = `${args.itemType.charAt(0).toUpperCase() + args.itemType.slice(1)} not found`;
+                    if (args.id)
+                        errorMsg += ` with ID "${args.id}"`;
+                    if (args.name)
+                        errorMsg += `${args.id ? ' or' : ' with'} name "${args.name}"`;
+                    errorMsg += '.';
+                }
+                else {
+                    errorMsg += `: ${result.error}`;
+                }
+            }
+            return {
+                content: [{
+                        type: "text",
+                        text: errorMsg
+                    }],
+                isError: true
+            };
+        }
+    }
+    catch (err) {
+        const error = err;
+        console.error(`Tool execution error: ${error.message}`);
+        return {
+            content: [{
+                    type: "text",
+                    text: `Error removing ${args.itemType}: ${error.message}`
+                }],
+            isError: true
+        };
+    }
+}

package/dist/tools/dumpDatabase.js

@@ -0,0 +1,121 @@
+import { executeOmniFocusScript } from '../utils/scriptExecution.js';
+// Main function to dump the database
+export async function dumpDatabase() {
+    try {
+        // Execute the OmniFocus script
+        const data = await executeOmniFocusScript('@omnifocusDump.js');
+        // wait 1 second
+        await new Promise(resolve => setTimeout(resolve, 1000));
+        // Create an empty database if no data returned
+        if (!data) {
+            return {
+                exportDate: new Date().toISOString(),
+                tasks: [],
+                projects: {},
+                folders: {},
+                tags: {}
+            };
+        }
+        // Initialize the database object
+        const database = {
+            exportDate: data.exportDate,
+            tasks: [],
+            projects: {},
+            folders: {},
+            tags: {}
+        };
+        // Process tasks
+        if (data.tasks && Array.isArray(data.tasks)) {
+            // Convert the tasks to our OmnifocusTask format
+            database.tasks = data.tasks.map((task) => {
+                // Get tag names from the tag IDs
+                const tagNames = (task.tags || []).map(tagId => {
+                    return data.tags[tagId]?.name || 'Unknown Tag';
+                });
+                return {
+                    id: String(task.id),
+                    name: String(task.name),
+                    note: String(task.note || ""),
+                    flagged: Boolean(task.flagged),
+                    completed: task.taskStatus === "Completed",
+                    completionDate: null, // Not available in the new format
+                    dropDate: null, // Not available in the new format
+                    taskStatus: String(task.taskStatus),
+                    active: task.taskStatus !== "Completed" && task.taskStatus !== "Dropped",
+                    dueDate: task.dueDate,
+                    deferDate: task.deferDate,
+                    estimatedMinutes: task.estimatedMinutes ? Number(task.estimatedMinutes) : null,
+                    tags: task.tags || [],
+                    tagNames: tagNames,
+                    parentId: task.parentTaskID || null,
+                    containingProjectId: task.projectID || null,
+                    projectId: task.projectID || null,
+                    childIds: task.children || [],
+                    hasChildren: (task.children && task.children.length > 0) || false,
+                    sequential: Boolean(task.sequential),
+                    completedByChildren: Boolean(task.completedByChildren),
+                    isRepeating: false, // Not available in the new format
+                    repetitionMethod: null, // Not available in the new format 
+                    repetitionRule: null, // Not available in the new format
+                    attachments: [], // Default empty array
+                    linkedFileURLs: [], // Default empty array
+                    notifications: [], // Default empty array
+                    shouldUseFloatingTimeZone: false // Default value
+                };
+            });
+        }
+        // Process projects
+        if (data.projects) {
+            for (const [id, project] of Object.entries(data.projects)) {
+                database.projects[id] = {
+                    id: String(project.id),
+                    name: String(project.name),
+                    status: String(project.status),
+                    folderID: project.folderID || null,
+                    sequential: Boolean(project.sequential),
+                    effectiveDueDate: project.effectiveDueDate,
+                    effectiveDeferDate: project.effectiveDeferDate,
+                    dueDate: project.dueDate,
+                    deferDate: project.deferDate,
+                    completedByChildren: Boolean(project.completedByChildren),
+                    containsSingletonActions: Boolean(project.containsSingletonActions),
+                    note: String(project.note || ""),
+                    tasks: project.tasks || [],
+                    flagged: false, // Default value
+                    estimatedMinutes: null // Default value
+                };
+            }
+        }
+        // Process folders
+        if (data.folders) {
+            for (const [id, folder] of Object.entries(data.folders)) {
+                database.folders[id] = {
+                    id: String(folder.id),
+                    name: String(folder.name),
+                    parentFolderID: folder.parentFolderID || null,
+                    status: String(folder.status),
+                    projects: folder.projects || [],
+                    subfolders: folder.subfolders || []
+                };
+            }
+        }
+        // Process tags
+        if (data.tags) {
+            for (const [id, tag] of Object.entries(data.tags)) {
+                database.tags[id] = {
+                    id: String(tag.id),
+                    name: String(tag.name),
+                    parentTagID: tag.parentTagID || null,
+                    active: Boolean(tag.active),
+                    allowsNextAction: Boolean(tag.allowsNextAction),
+                    tasks: tag.tasks || []
+                };
+            }
+        }
+        return database;
+    }
+    catch (error) {
+        console.error("Error in dumpDatabase:", error);
+        throw error;
+    }
+}

package/dist/tools/dumpDatabaseOptimized.js

@@ -0,0 +1,192 @@
+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) {
+    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() {
+    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) {
+    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;
+}