@iflow-mcp/omnifocus-mcp 1.2.3

package/src/tools/definitions/dumpDatabase.ts

@@ -0,0 +1,311 @@
+import { z } from 'zod';
+import { dumpDatabase } from '../dumpDatabase.js';
+import { RequestHandlerExtra } from '@modelcontextprotocol/sdk/shared/protocol.js';
+
+export const schema = z.object({
+  hideCompleted: z.boolean().optional().describe("Set to false to show completed and dropped tasks (default: true)"),
+  hideRecurringDuplicates: z.boolean().optional().describe("Set to true to hide duplicate instances of recurring tasks (default: true)")
+});
+
+export async function handler(args: z.infer<typeof schema>, extra: RequestHandlerExtra) {
+  try {
+    // Get raw database
+    const database = await dumpDatabase();
+
+    // Format as compact report
+    const formattedReport = formatCompactReport(database, {
+      hideCompleted: args.hideCompleted !== false, // Default to true
+      hideRecurringDuplicates: args.hideRecurringDuplicates !== false // Default to true
+    });
+
+    return {
+      content: [{
+        type: "text" as const,
+        text: formattedReport
+      }]
+    };
+  } catch (err: unknown) {
+    return {
+      content: [{
+        type: "text" as const,
+        text: `Error generating report. Please ensure OmniFocus is running and try again.`
+      }],
+      isError: true
+    };
+  }
+}
+
+// Function to format date in compact format (M/D)
+function formatCompactDate(isoDate: string | null): string {
+  if (!isoDate) return '';
+
+  const date = new Date(isoDate);
+  return `${date.getMonth() + 1}/${date.getDate()}`;
+}
+
+// Function to format the database in the compact report format
+function formatCompactReport(database: any, options: { hideCompleted: boolean, hideRecurringDuplicates: boolean }): string {
+  const { hideCompleted, hideRecurringDuplicates } = options;
+
+  // Get current date for the header
+  const today = new Date();
+  const dateStr = today.toISOString().split('T')[0];
+
+  let output = `# OMNIFOCUS [${dateStr}]\n\n`;
+
+  // Add legend
+  output += `FORMAT LEGEND:
+F: Folder | P: Project | •: Task | 🚩: Flagged
+Dates: [M/D] | Duration: (30m) or (2h) | Tags: <tag1,tag2>
+Status: #next #avail #block #due #over #compl #drop\n\n`;
+
+  // Map of folder IDs to folder objects for quick lookup
+  const folderMap = new Map();
+  Object.values(database.folders).forEach((folder: any) => {
+    folderMap.set(folder.id, folder);
+  });
+
+  // Get all tag names to compute minimum unique prefixes
+  const allTagNames = Object.values(database.tags).map((tag: any) => tag.name);
+  const tagPrefixMap = computeMinimumUniquePrefixes(allTagNames);
+
+  // Function to get folder hierarchy path
+  function getFolderPath(folderId: string): string[] {
+    const path = [];
+    let currentId = folderId;
+
+    while (currentId) {
+      const folder = folderMap.get(currentId);
+      if (!folder) break;
+
+      path.unshift(folder.name);
+      currentId = folder.parentFolderID;
+    }
+
+    return path;
+  }
+
+  // Get root folders (no parent)
+  const rootFolders = Object.values(database.folders).filter((folder: any) => !folder.parentFolderID);
+
+  // Process folders recursively
+  function processFolder(folder: any, level: number): string {
+    const indent = '   '.repeat(level);
+    let folderOutput = `${indent}F: ${folder.name}\n`;
+
+    // Process subfolders
+    if (folder.subfolders && folder.subfolders.length > 0) {
+      for (const subfolderId of folder.subfolders) {
+        const subfolder = database.folders[subfolderId];
+        if (subfolder) {
+          folderOutput += `${processFolder(subfolder, level + 1)}`;
+        }
+      }
+    }
+
+    // Process projects in this folder
+    if (folder.projects && folder.projects.length > 0) {
+      for (const projectId of folder.projects) {
+        const project = database.projects[projectId];
+        if (project) {
+          folderOutput += processProject(project, level + 1);
+        }
+      }
+    }
+
+    return folderOutput;
+  }
+
+  // Process a project
+  function processProject(project: any, level: number): string {
+    const indent = '   '.repeat(level);
+
+    // Skip if it's completed or dropped and we're hiding completed items
+    if (hideCompleted && (project.status === 'Done' || project.status === 'Dropped')) {
+      return '';
+    }
+
+    // Format project status info
+    let statusInfo = '';
+    if (project.status === 'OnHold') {
+      statusInfo = ' [OnHold]';
+    } else if (project.status === 'Dropped') {
+      statusInfo = ' [Dropped]';
+    }
+
+    // Add due date if present
+    if (project.dueDate) {
+      const dueDateStr = formatCompactDate(project.dueDate);
+      statusInfo += statusInfo ? ` [DUE:${dueDateStr}]` : ` [DUE:${dueDateStr}]`;
+    }
+
+    // Add flag if present
+    const flaggedSymbol = project.flagged ? ' 🚩' : '';
+
+    let projectOutput = `${indent}P: ${project.name}${flaggedSymbol}${statusInfo}\n`;
+
+    // Process tasks in this project
+    const projectTasks = database.tasks.filter((task: any) =>
+      task.projectId === project.id && !task.parentId
+    );
+
+    if (projectTasks.length > 0) {
+      for (const task of projectTasks) {
+        projectOutput += processTask(task, level + 1);
+      }
+    }
+
+    return projectOutput;
+  }
+
+  // Process a task
+  function processTask(task: any, level: number): string {
+    const indent = '   '.repeat(level);
+
+    // Skip if it's completed or dropped and we're hiding completed items
+    if (hideCompleted && (task.completed || task.taskStatus === 'Completed' || task.taskStatus === 'Dropped')) {
+      return '';
+    }
+
+    // Flag symbol
+    const flagSymbol = task.flagged ? '🚩 ' : '';
+
+    // Format dates
+    let dateInfo = '';
+    if (task.dueDate) {
+      const dueDateStr = formatCompactDate(task.dueDate);
+      dateInfo += ` [DUE:${dueDateStr}]`;
+    }
+    if (task.deferDate) {
+      const deferDateStr = formatCompactDate(task.deferDate);
+      dateInfo += ` [defer:${deferDateStr}]`;
+    }
+
+    // Format duration
+    let durationStr = '';
+    if (task.estimatedMinutes) {
+      // Convert to hours if >= 60 minutes
+      if (task.estimatedMinutes >= 60) {
+        const hours = Math.floor(task.estimatedMinutes / 60);
+        durationStr = ` (${hours}h)`;
+      } else {
+        durationStr = ` (${task.estimatedMinutes}m)`;
+      }
+    }
+
+    // Format tags
+    let tagsStr = '';
+    if (task.tagNames && task.tagNames.length > 0) {
+      // Use minimum unique prefixes for tag names
+      const abbreviatedTags = task.tagNames.map((tag: string) => {
+        return tagPrefixMap.get(tag) || tag;
+      });
+
+      tagsStr = ` <${abbreviatedTags.join(',')}>`;
+    }
+
+    // Format status
+    let statusStr = '';
+    switch (task.taskStatus) {
+      case 'Next':
+        statusStr = ' #next';
+        break;
+      case 'Available':
+        statusStr = ' #avail';
+        break;
+      case 'Blocked':
+        statusStr = ' #block';
+        break;
+      case 'DueSoon':
+        statusStr = ' #due';
+        break;
+      case 'Overdue':
+        statusStr = ' #over';
+        break;
+      case 'Completed':
+        statusStr = ' #compl';
+        break;
+      case 'Dropped':
+        statusStr = ' #drop';
+        break;
+    }
+
+    let taskOutput = `${indent}• ${flagSymbol}${task.name}${dateInfo}${durationStr}${tagsStr}${statusStr}\n`;
+
+    // Process subtasks
+    if (task.childIds && task.childIds.length > 0) {
+      const childTasks = database.tasks.filter((t: any) => task.childIds.includes(t.id));
+
+      for (const childTask of childTasks) {
+        taskOutput += processTask(childTask, level + 1);
+      }
+    }
+
+    return taskOutput;
+  }
+
+  // Process all root folders
+  for (const folder of rootFolders) {
+    output += processFolder(folder, 0);
+  }
+
+  // Process projects not in any folder (if any)
+  const rootProjects = Object.values(database.projects).filter((project: any) => !project.folderID);
+
+  for (const project of rootProjects) {
+    output += processProject(project, 0);
+  }
+
+  // Process tasks in the Inbox (not in any project)
+  const inboxTasks = database.tasks.filter(function (task: any) {
+    return !task.projectId;
+  });
+
+  if (inboxTasks.length > 0) {
+    output += `\nP: Inbox\n`;
+    for (const task of inboxTasks) {
+      output += processTask(task, 0);
+    }
+  }
+
+  return output;
+}
+
+// Compute minimum unique prefixes for all tags (minimum 3 characters)
+function computeMinimumUniquePrefixes(tagNames: string[]): Map<string, string> {
+  const prefixMap = new Map<string, string>();
+
+  // For each tag name
+  for (const tagName of tagNames) {
+    // Start with minimum length of 3
+    let prefixLength = 3;
+    let isUnique = false;
+
+    // Keep increasing prefix length until we find a unique prefix
+    while (!isUnique && prefixLength <= tagName.length) {
+      const prefix = tagName.substring(0, prefixLength);
+
+      // Check if this prefix uniquely identifies the tag
+      isUnique = tagNames.every(otherTag => {
+        // If it's the same tag, skip comparison
+        if (otherTag === tagName) return true;
+
+        // If the other tag starts with the same prefix, it's not unique
+        return !otherTag.startsWith(prefix);
+      });
+
+      if (isUnique) {
+        prefixMap.set(tagName, prefix);
+      } else {
+        prefixLength++;
+      }
+    }
+
+    // If we couldn't find a unique prefix, use the full tag name
+    if (!isUnique) {
+      prefixMap.set(tagName, tagName);
+    }
+  }
+
+  return prefixMap;
+}

package/src/tools/definitions/editItem.ts

@@ -0,0 +1,96 @@
+import { z } from 'zod';
+import { editItem, EditItemParams } from '../primitives/editItem.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 edit"),
+  name: z.string().optional().describe("The name of the task or project to edit (as fallback if ID not provided)"),
+  itemType: z.enum(['task', 'project']).describe("Type of item to edit ('task' or 'project')"),
+  
+  // Common editable fields
+  newName: z.string().optional().describe("New name for the item"),
+  newNote: z.string().optional().describe("New note for the item"),
+  newDueDate: z.string().optional().describe("New due date in ISO format (YYYY-MM-DD or full ISO date); set to empty string to clear"),
+  newDeferDate: z.string().optional().describe("New defer date in ISO format (YYYY-MM-DD or full ISO date); set to empty string to clear"),
+  newFlagged: z.boolean().optional().describe("Set flagged status (set to false for no flag, true for flag)"),
+  newEstimatedMinutes: z.number().optional().describe("New estimated minutes"),
+  
+  // Task-specific fields
+  newStatus: z.enum(['incomplete', 'completed', 'dropped']).optional().describe("New status for tasks (incomplete, completed, dropped)"),
+  addTags: z.array(z.string()).optional().describe("Tags to add to the task"),
+  removeTags: z.array(z.string()).optional().describe("Tags to remove from the task"),
+  replaceTags: z.array(z.string()).optional().describe("Tags to replace all existing tags with"),
+  
+  // Project-specific fields
+  newSequential: z.boolean().optional().describe("Whether the project should be sequential"),
+  newFolderName: z.string().optional().describe("New folder to move the project to"),
+  newProjectStatus: z.enum(['active', 'completed', 'dropped', 'onHold']).optional().describe("New status for projects")
+});
+
+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 edit an item."
+        }],
+        isError: true
+      };
+    }
+    
+    // Call the editItem function 
+    const result = await editItem(args as EditItemParams);
+    
+    if (result.success) {
+      // Item was edited successfully
+      const itemTypeLabel = args.itemType === 'task' ? 'Task' : 'Project';
+      let changedText = '';
+      
+      if (result.changedProperties) {
+        changedText = ` (${result.changedProperties})`;
+      }
+      
+      return {
+        content: [{
+          type: "text" as const,
+          text: `✅ ${itemTypeLabel} "${result.name}" updated successfully${changedText}.`
+        }]
+      };
+    } else {
+      // Item editing failed
+      let errorMsg = `Failed to update ${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 updating ${args.itemType}: ${error.message}`
+      }],
+      isError: true
+    };
+  }
+} 

package/src/tools/definitions/getPerspectiveView.ts

@@ -0,0 +1,125 @@
+import { z } from 'zod';
+import { getPerspectiveView } from '../primitives/getPerspectiveView.js';
+import { RequestHandlerExtra } from '@modelcontextprotocol/sdk/shared/protocol.js';
+
+export const schema = z.object({
+  perspectiveName: z.string().describe("Name of the perspective to view (e.g., 'Inbox', 'Projects', 'Flagged', or custom perspective name)"),
+  
+  limit: z.number().optional().describe("Maximum number of items to return. Default: 100"),
+  
+  includeMetadata: z.boolean().optional().describe("Include additional metadata like project names, tags, dates. Default: true"),
+  
+  fields: z.array(z.string()).optional().describe("Specific fields to include in the response. Reduces response size. Available fields: id, name, note, flagged, dueDate, deferDate, completionDate, taskStatus, projectName, tagNames, estimatedMinutes")
+});
+
+export async function handler(args: z.infer<typeof schema>, extra: RequestHandlerExtra) {
+  try {
+    const result = await getPerspectiveView({
+      perspectiveName: args.perspectiveName,
+      limit: args.limit ?? 100,
+      includeMetadata: args.includeMetadata ?? true,
+      fields: args.fields
+    });
+    
+    if (result.success) {
+      const items = result.items || [];
+      
+      // Format the output
+      let output = `## ${args.perspectiveName} Perspective (${items.length} items)\n\n`;
+      
+      if (items.length === 0) {
+        output += "No items visible in this perspective.";
+      } else {
+        // Format each item
+        items.forEach(item => {
+          const parts = [];
+          
+          // Core display
+          const flag = item.flagged ? '🚩 ' : '';
+          const checkbox = item.completed ? '☑' : '☐';
+          parts.push(`${checkbox} ${flag}${item.name || 'Unnamed'}`);
+          
+          // Project context
+          if (item.projectName) {
+            parts.push(`(${item.projectName})`);
+          }
+          
+          // Due date
+          if (item.dueDate) {
+            const date = new Date(item.dueDate);
+            const dateStr = `${date.getMonth() + 1}/${date.getDate()}`;
+            parts.push(`[due: ${dateStr}]`);
+          }
+          
+          // Defer date
+          if (item.deferDate) {
+            const date = new Date(item.deferDate);
+            const dateStr = `${date.getMonth() + 1}/${date.getDate()}`;
+            parts.push(`[defer: ${dateStr}]`);
+          }
+          
+          // Time estimate
+          if (item.estimatedMinutes) {
+            const hours = item.estimatedMinutes >= 60 
+              ? `${Math.floor(item.estimatedMinutes / 60)}h${item.estimatedMinutes % 60 > 0 ? (item.estimatedMinutes % 60) + 'm' : ''}`
+              : `${item.estimatedMinutes}m`;
+            parts.push(`(${hours})`);
+          }
+          
+          // Tags
+          if (item.tagNames && item.tagNames.length > 0) {
+            parts.push(`<${item.tagNames.join(',')}>`);
+          }
+          
+          // Status
+          if (item.taskStatus && item.taskStatus !== 'Available') {
+            parts.push(`#${item.taskStatus.toLowerCase()}`);
+          }
+          
+          // ID for reference
+          if (item.id) {
+            parts.push(`[${item.id}]`);
+          }
+          
+          output += `• ${parts.join(' ')}\n`;
+          
+          // Add note preview if present and not too long
+          if (item.note && item.note.trim()) {
+            const notePreview = item.note.trim().split('\n')[0].substring(0, 80);
+            const ellipsis = item.note.length > 80 || item.note.includes('\n') ? '...' : '';
+            output += `  └─ ${notePreview}${ellipsis}\n`;
+          }
+        });
+      }
+      
+      if (items.length === args.limit) {
+        output += `\n⚠️ Results limited to ${args.limit} items. More may be available in this perspective.`;
+      }
+      
+      return {
+        content: [{
+          type: "text" as const,
+          text: output
+        }]
+      };
+    } else {
+      return {
+        content: [{
+          type: "text" as const,
+          text: `Failed to get perspective view: ${result.error}`
+        }],
+        isError: true
+      };
+    }
+  } catch (err: unknown) {
+    const error = err as Error;
+    console.error(`Error getting perspective view: ${error.message}`);
+    return {
+      content: [{
+        type: "text" as const,
+        text: `Error getting perspective view: ${error.message}`
+      }],
+      isError: true
+    };
+  }
+}

package/src/tools/definitions/listPerspectives.ts

@@ -0,0 +1,72 @@
+import { z } from 'zod';
+import { listPerspectives } from '../primitives/listPerspectives.js';
+import { RequestHandlerExtra } from '@modelcontextprotocol/sdk/shared/protocol.js';
+
+export const schema = z.object({
+  includeBuiltIn: z.boolean().optional().describe("Include built-in perspectives (Inbox, Projects, Tags, etc.). Default: true"),
+  includeCustom: z.boolean().optional().describe("Include custom perspectives (Pro feature). Default: true")
+});
+
+export async function handler(args: z.infer<typeof schema>, extra: RequestHandlerExtra) {
+  try {
+    const result = await listPerspectives({
+      includeBuiltIn: args.includeBuiltIn ?? true,
+      includeCustom: args.includeCustom ?? true
+    });
+    
+    if (result.success) {
+      const perspectives = result.perspectives || [];
+      
+      // Format the perspectives in a readable way
+      let output = `## Available Perspectives (${perspectives.length})\n\n`;
+      
+      // Group by type
+      const builtIn = perspectives.filter(p => p.type === 'builtin');
+      const custom = perspectives.filter(p => p.type === 'custom');
+      
+      if (builtIn.length > 0) {
+        output += `### Built-in Perspectives\n`;
+        builtIn.forEach(p => {
+          output += `• ${p.name}\n`;
+        });
+      }
+      
+      if (custom.length > 0) {
+        if (builtIn.length > 0) output += '\n';
+        output += `### Custom Perspectives\n`;
+        custom.forEach(p => {
+          output += `• ${p.name}\n`;
+        });
+      }
+      
+      if (perspectives.length === 0) {
+        output = "No perspectives found.";
+      }
+      
+      return {
+        content: [{
+          type: "text" as const,
+          text: output
+        }]
+      };
+    } else {
+      return {
+        content: [{
+          type: "text" as const,
+          text: `Failed to list perspectives: ${result.error}`
+        }],
+        isError: true
+      };
+    }
+  } catch (err: unknown) {
+    const error = err as Error;
+    console.error(`Error listing perspectives: ${error.message}`);
+    return {
+      content: [{
+        type: "text" as const,
+        text: `Error listing perspectives: ${error.message}`
+      }],
+      isError: true
+    };
+  }
+}