@iflow-mcp/omnifocus-mcp 1.2.3

package/dist/tools/definitions/dumpDatabase.js

@@ -0,0 +1,259 @@
+import { z } from 'zod';
+import { dumpDatabase } from '../dumpDatabase.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, extra) {
+    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",
+                    text: formattedReport
+                }]
+        };
+    }
+    catch (err) {
+        return {
+            content: [{
+                    type: "text",
+                    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) {
+    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, options) {
+    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) => {
+        folderMap.set(folder.id, folder);
+    });
+    // Get all tag names to compute minimum unique prefixes
+    const allTagNames = Object.values(database.tags).map((tag) => tag.name);
+    const tagPrefixMap = computeMinimumUniquePrefixes(allTagNames);
+    // Function to get folder hierarchy path
+    function getFolderPath(folderId) {
+        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) => !folder.parentFolderID);
+    // Process folders recursively
+    function processFolder(folder, level) {
+        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, level) {
+        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) => 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, level) {
+        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) => {
+                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) => 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) => !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) {
+        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) {
+    const prefixMap = new Map();
+    // 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/dist/tools/definitions/editItem.js

@@ -0,0 +1,88 @@
+import { z } from 'zod';
+import { editItem } from '../primitives/editItem.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, 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 edit an item."
+                    }],
+                isError: true
+            };
+        }
+        // Call the editItem function 
+        const result = await editItem(args);
+        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",
+                        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",
+                        text: errorMsg
+                    }],
+                isError: true
+            };
+        }
+    }
+    catch (err) {
+        const error = err;
+        console.error(`Tool execution error: ${error.message}`);
+        return {
+            content: [{
+                    type: "text",
+                    text: `Error updating ${args.itemType}: ${error.message}`
+                }],
+            isError: true
+        };
+    }
+}

package/dist/tools/definitions/getPerspectiveView.js

@@ -0,0 +1,107 @@
+import { z } from 'zod';
+import { getPerspectiveView } from '../primitives/getPerspectiveView.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, extra) {
+    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",
+                        text: output
+                    }]
+            };
+        }
+        else {
+            return {
+                content: [{
+                        type: "text",
+                        text: `Failed to get perspective view: ${result.error}`
+                    }],
+                isError: true
+            };
+        }
+    }
+    catch (err) {
+        const error = err;
+        console.error(`Error getting perspective view: ${error.message}`);
+        return {
+            content: [{
+                    type: "text",
+                    text: `Error getting perspective view: ${error.message}`
+                }],
+            isError: true
+        };
+    }
+}

package/dist/tools/definitions/listPerspectives.js

@@ -0,0 +1,65 @@
+import { z } from 'zod';
+import { listPerspectives } from '../primitives/listPerspectives.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, extra) {
+    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",
+                        text: output
+                    }]
+            };
+        }
+        else {
+            return {
+                content: [{
+                        type: "text",
+                        text: `Failed to list perspectives: ${result.error}`
+                    }],
+                isError: true
+            };
+        }
+    }
+    catch (err) {
+        const error = err;
+        console.error(`Error listing perspectives: ${error.message}`);
+        return {
+            content: [{
+                    type: "text",
+                    text: `Error listing perspectives: ${error.message}`
+                }],
+            isError: true
+        };
+    }
+}