omnifocus-mcp-enhanced 1.1.0

package/dist/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/dist/utils/scriptExecution.js

@@ -0,0 +1,113 @@
+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) {
+    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, args) {
+    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/package.json

@@ -0,0 +1,51 @@
+{
+  "name": "omnifocus-mcp-enhanced",
+  "type": "module",
+  "version": "1.1.0",
+  "description": "Enhanced Model Context Protocol (MCP) server for OmniFocus with complete subtask support and advanced task management features",
+  "main": "dist/server.js",
+  "bin": {
+    "omnifocus-mcp-enhanced": "./cli.cjs"
+  },
+  "scripts": {
+    "build": "tsc && npm run copy-files && chmod 755 dist/server.js",
+    "copy-files": "mkdir -p dist/utils/omnifocusScripts && cp src/utils/omnifocusScripts/*.js dist/utils/omnifocusScripts/",
+    "start": "node dist/server.js",
+    "dev": "tsc -w",
+    "prepublishOnly": "npm run build",
+    "test": "echo \"Test passed - manual testing required with OmniFocus\""
+  },
+  "dependencies": {
+    "@modelcontextprotocol/sdk": "^1.8.0",
+    "zod": "^3.22.4"
+  },
+  "devDependencies": {
+    "@types/node": "^20.11.19",
+    "typescript": "^5.3.3"
+  },
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/your-username/omnifocus-mcp-enhanced.git"
+  },
+  "homepage": "https://github.com/your-username/omnifocus-mcp-enhanced",
+  "keywords": [
+    "omnifocus",
+    "mcp",
+    "claude",
+    "task-management",
+    "ai",
+    "subtasks",
+    "enhanced",
+    "productivity",
+    "macos"
+  ],
+  "author": {
+    "name": "Your Name",
+    "email": "your.email@example.com"
+  },
+  "engines": {
+    "node": ">=18.0.0"
+  },
+  "os": ["darwin"],
+  "license": "MIT"
+}

package/publish.sh

@@ -0,0 +1,148 @@
+#!/bin/bash
+
+# OmniFocus MCP Enhanced 发布脚本
+# 用于发布到 NPM
+
+set -e
+
+echo "🚀 OmniFocus MCP Enhanced 发布脚本"
+echo "================================="
+
+# 检查是否已经登录 npm
+if ! npm whoami > /dev/null 2>&1; then
+    echo "❌ 请先登录 NPM: npm login"
+    exit 1
+fi
+
+echo "👤 当前 NPM 用户: $(npm whoami)"
+
+# 检查参数
+if [ "$1" = "check" ]; then
+    echo "🔍 检查发布准备状态..."
+    
+    # 检查必要文件
+    echo "📝 检查必要文件..."
+    required_files=("package.json" "README.md" "CLAUDE.md" "cli.cjs" ".npmignore")
+    for file in "${required_files[@]}"; do
+        if [ -f "$file" ]; then
+            echo "  ✅ $file"
+        else
+            echo "  ❌ $file (缺失)"
+            exit 1
+        fi
+    done
+    
+    # 检查构建产物
+    echo "🔨 检查构建产物..."
+    if [ -d "dist" ]; then
+        echo "  ✅ dist/ 目录存在"
+        if [ -f "dist/server.js" ]; then
+            echo "  ✅ dist/server.js 存在"
+        else
+            echo "  ❌ dist/server.js 不存在，请运行 npm run build"
+            exit 1
+        fi
+    else
+        echo "  ❌ dist/ 目录不存在，请运行 npm run build"
+        exit 1
+    fi
+    
+    # 检查 package.json 信息
+    echo "📦 检查 package.json..."
+    PACKAGE_NAME=$(node -p "require('./package.json').name")
+    PACKAGE_VERSION=$(node -p "require('./package.json').version")
+    echo "  📋 包名: $PACKAGE_NAME"
+    echo "  🏷️  版本: $PACKAGE_VERSION"
+    
+    # 检查版本是否已存在
+    echo "🔍 检查版本冲突..."
+    if npm view "$PACKAGE_NAME@$PACKAGE_VERSION" version > /dev/null 2>&1; then
+        echo "  ⚠️  版本 $PACKAGE_VERSION 已存在于 NPM"
+        echo "  💡 请更新 package.json 中的版本号"
+        exit 1
+    else
+        echo "  ✅ 版本 $PACKAGE_VERSION 可用"
+    fi
+    
+    # 测试打包
+    echo "📦 测试打包..."
+    npm pack --dry-run > /dev/null
+    echo "  ✅ 打包测试通过"
+    
+    echo ""
+    echo "✅ 所有检查通过！可以发布。"
+    echo "🚀 运行 './publish.sh release' 开始发布"
+
+elif [ "$1" = "release" ]; then
+    echo "🚀 开始发布流程..."
+    
+    # 先运行检查
+    echo "🔍 运行发布前检查..."
+    ./publish.sh check
+    
+    PACKAGE_NAME=$(node -p "require('./package.json').name")
+    PACKAGE_VERSION=$(node -p "require('./package.json').version")
+    
+    echo ""
+    echo "📦 准备发布:"
+    echo "  📋 包名: $PACKAGE_NAME"
+    echo "  🏷️  版本: $PACKAGE_VERSION"
+    echo ""
+    
+    read -p "确认发布? (y/N): " -n 1 -r
+    echo
+    if [[ ! $REPLY =~ ^[Yy]$ ]]; then
+        echo "❌ 发布已取消"
+        exit 1
+    fi
+    
+    # 清理并重新构建
+    echo "🔨 重新构建项目..."
+    rm -rf dist/
+    npm run build
+    
+    # 发布到 NPM
+    echo "📤 发布到 NPM..."
+    npm publish
+    
+    echo ""
+    echo "🎉 发布成功！"
+    echo ""
+    echo "📋 用户可以通过以下方式安装:"
+    echo ""
+    echo "# Claude Code 一键安装"
+    echo "claude mcp add omnifocus-enhanced -- npx -y $PACKAGE_NAME"
+    echo ""
+    echo "# 或者全局安装"
+    echo "npm install -g $PACKAGE_NAME"
+    echo "claude mcp add omnifocus-enhanced -- $PACKAGE_NAME"
+    echo ""
+    echo "🔗 NPM 包地址: https://www.npmjs.com/package/$PACKAGE_NAME"
+
+elif [ "$1" = "version" ]; then
+    if [ -z "$2" ]; then
+        echo "❌ 请指定版本类型: patch, minor, major"
+        echo "用法: ./publish.sh version patch"
+        exit 1
+    fi
+    
+    echo "🏷️  更新版本..."
+    npm version "$2" --no-git-tag-version
+    NEW_VERSION=$(node -p "require('./package.json').version")
+    echo "✅ 版本已更新为: $NEW_VERSION"
+    echo "💡 现在可以运行 './publish.sh release' 发布新版本"
+
+else
+    echo "用法:"
+    echo "  ./publish.sh check           # 检查发布准备状态"
+    echo "  ./publish.sh version <type>  # 更新版本 (patch/minor/major)"
+    echo "  ./publish.sh release         # 发布到 NPM"
+    echo ""
+    echo "发布流程:"
+    echo "  1. ./publish.sh check        # 检查状态"
+    echo "  2. ./publish.sh version patch # 更新版本（可选）"
+    echo "  3. ./publish.sh release      # 发布"
+    echo ""
+    echo "发布后用户安装命令:"
+    echo "  claude mcp add omnifocus-enhanced -- npx -y omnifocus-mcp-enhanced"
+fi