@iflow-mcp/omnifocus-mcp 1.2.3

package/src/tools/definitions/queryOmnifocus.ts

@@ -0,0 +1,212 @@
+import { z } from 'zod';
+import { queryOmnifocus, QueryOmnifocusParams } from '../primitives/queryOmnifocus.js';
+import { RequestHandlerExtra } from '@modelcontextprotocol/sdk/shared/protocol.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: z.infer<typeof schema>, extra: RequestHandlerExtra) {
+  try {
+    // Call the queryOmniFocus function
+    const result = await queryOmnifocus(args as QueryOmnifocusParams);
+    
+    if (result.success) {
+      // Format response based on whether it's a summary or full results
+      if (args.summary) {
+        return {
+          content: [{
+            type: "text" as const,
+            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" as const,
+            text: output
+          }]
+        };
+      }
+    } else {
+      return {
+        content: [{
+          type: "text" as const,
+          text: `Query failed: ${result.error}`
+        }],
+        isError: true
+      };
+    }
+  } catch (err: unknown) {
+    const error = err as Error;
+    console.error(`Query execution error: ${error.message}`);
+    return {
+      content: [{
+        type: "text" as const,
+        text: `Error executing query: ${error.message}`
+      }],
+      isError: true
+    };
+  }
+}
+
+// Helper function to format query results in a compact way
+function formatQueryResults(items: any[], entity: string, filters?: any): string {
+  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: any): string {
+  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: any[]): string {
+  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: any[]): string {
+  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: any[]): string {
+  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: string): string {
+  const date = new Date(dateStr);
+  return `${date.getMonth() + 1}/${date.getDate()}`;
+}

package/src/tools/definitions/removeItem.ts

@@ -0,0 +1,86 @@
+import { z } from 'zod';
+import { removeItem, RemoveItemParams } from '../primitives/removeItem.js';
+import { RequestHandlerExtra } from '@modelcontextprotocol/sdk/shared/protocol.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: z.infer<typeof schema>, extra: RequestHandlerExtra) {
+  try {
+    // Validate that either id or name is provided
+    if (!args.id && !args.name) {
+      return {
+        content: [{
+          type: "text" as const,
+          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" as const,
+          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 as RemoveItemParams);
+    
+    if (result.success) {
+      // Item was removed successfully
+      const itemTypeLabel = args.itemType === 'task' ? 'Task' : 'Project';
+      
+      return {
+        content: [{
+          type: "text" as const,
+          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" as const,
+          text: errorMsg
+        }],
+        isError: true
+      };
+    }
+  } catch (err: unknown) {
+    const error = err as Error;
+    console.error(`Tool execution error: ${error.message}`);
+    
+    return {
+      content: [{
+        type: "text" as const,
+        text: `Error removing ${args.itemType}: ${error.message}`
+      }],
+      isError: true
+    };
+  }
+} 

package/src/tools/dumpDatabase.ts

@@ -0,0 +1,196 @@
+import { OmnifocusDatabase, OmnifocusTask, OmnifocusProject, OmnifocusFolder, OmnifocusTag } from '../types.js';
+import { executeOmniFocusScript } from '../utils/scriptExecution.js';
+
+import fs from 'fs';
+// Define interfaces for the data returned from the script
+interface OmnifocusDumpTask {
+  id: string;
+  name: string;
+  note?: string;
+  taskStatus: string;
+  flagged: boolean;
+  dueDate: string | null;
+  deferDate: string | null;
+  effectiveDueDate: string | null;
+  effectiveDeferDate: string | null;
+  estimatedMinutes: number | null;
+  completedByChildren: boolean;
+  sequential: boolean;
+  tags: string[];
+  projectID: string | null;
+  parentTaskID: string | null;
+  children: string[];
+  inInbox: boolean;
+}
+
+interface OmnifocusDumpProject {
+  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[];
+}
+
+interface OmnifocusDumpFolder {
+  id: string;
+  name: string;
+  parentFolderID: string | null;
+  status: string;
+  projects: string[];
+  subfolders: string[];
+}
+
+interface OmnifocusDumpTag {
+  id: string;
+  name: string;
+  parentTagID: string | null;
+  active: boolean;
+  allowsNextAction: boolean;
+  tasks: string[];
+}
+
+interface OmnifocusDumpData {
+  exportDate: string;
+  tasks: OmnifocusDumpTask[];
+  projects: Record<string, OmnifocusDumpProject>;
+  folders: Record<string, OmnifocusDumpFolder>;
+  tags: Record<string, OmnifocusDumpTag>;
+}
+
+// Main function to dump the database
+export async function dumpDatabase(): Promise<OmnifocusDatabase> {
+  
+  try {
+    // Execute the OmniFocus script
+    const data = await executeOmniFocusScript('@omnifocusDump.js') as OmnifocusDumpData;
+    // 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: OmnifocusDatabase = {
+      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: OmnifocusDumpTask) => {
+        // 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;
+  }
+}
+