omnifocus_mcp 1.0.0

data/lib/omnifocus_mcp/tools/operations/batch_add_items/bulk_executor.rb

@@ -0,0 +1,94 @@
+# frozen_string_literal: true
+
+require_relative "../../../parsers/apple_script_envelope"
+require_relative "../../../infrastructure/script_runner"
+require_relative "../../../utils/blank"
+require_relative "../../../result"
+require_relative "../../generators/add_omnifocus_task"
+require_relative "param_builder"
+
+module OmnifocusMcp
+  module Tools
+    module Operations
+      class BatchAddItems
+        # Runs eligible batch adds in a single osascript invocation instead of
+        # one process per item. Large MCP batches (20+ tasks) were timing out
+        # when each item spawned its own osascript call.
+        module BulkExecutor
+          # Independent task batches at or above this size use one osascript call.
+          BULK_MIN_ITEMS = 2
+
+          class << self
+            # @param batch_items [Array<BatchItem>] only pending items are executed
+            # @return [Array<OmnifocusMcp::Result>, nil] per-item results in pending
+            #   order, or +nil+ when bulk is not eligible or the script fails
+            def run(batch_items, execute_applescript: Infrastructure::ScriptRunner.method(:execute_applescript))
+              pending = batch_items.select(&:pending?)
+              return nil unless eligible?(pending)
+
+              params_list = pending.map do |bi|
+                ParamBuilder.task(bi.payload, parent_task_id: nil, project_name: bi.payload.project_name)
+              end
+              script = Generators::AddOmniFocusTask.generate_bulk_apple_script(params_list)
+
+              stdout, stderr, status = execute_applescript.call(script)
+              log_stderr(stderr)
+
+              return nil unless status.success?
+
+              parse_bulk_results(stdout, expected_count: pending.length)
+            end
+
+            def eligible?(batch_items)
+              return false if batch_items.length < BULK_MIN_ITEMS
+
+              batch_items.all? { |bi| bi.payload.type.to_s == "task" } &&
+                batch_items.none? { |bi| needs_sequential_resolution?(bi.payload) }
+            end
+
+            def needs_sequential_resolution?(payload)
+              [
+                payload.parent_temp_id,
+                payload.parent_task_id,
+                payload.parent_task_name
+              ].any? { !Utils::Blank.blank?(it) }
+            end
+
+            private
+
+            def log_stderr(stderr)
+              return if stderr.nil? || stderr.empty?
+
+              OmnifocusMcp.logger.warn("[batch_add_items] AppleScript stderr: #{stderr}")
+            end
+
+            def parse_bulk_results(stdout, expected_count:)
+              parsed = Parsers::AppleScriptEnvelope.parse(
+                stdout:,
+                default_error: "Unknown error in batch_add_items bulk add"
+              ) do |hash|
+                items = hash["items"]
+                unless items.is_a?(Array) && items.length == expected_count
+                  next OmnifocusMcp::Result.error("item count mismatch")
+                end
+
+                results = items.map { |item| parse_bulk_item(item) }
+                results.find(&:error?) || OmnifocusMcp::Result.ok(results)
+              end
+
+              parsed.error? ? nil : parsed.ok
+            end
+
+            def parse_bulk_item(item)
+              unless item.is_a?(Hash) && item["taskId"]
+                return OmnifocusMcp::Result.error("Missing taskId in bulk response")
+              end
+
+              OmnifocusMcp::Result.ok(item["taskId"])
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/omnifocus_mcp/tools/operations/batch_add_items/cycle_detector.rb

@@ -0,0 +1,74 @@
+# frozen_string_literal: true
+
+require_relative "../../../utils/blank"
+
+module OmnifocusMcp
+  module Tools
+    module Operations
+      class BatchAddItems
+        # DFS over a temp_id -> parent_temp_id graph; collects a message for
+        # every temp_id participating in any cycle.
+        class CycleDetector
+          # @param temp_index [Hash{String => BatchItem}]
+          def initialize(temp_index)
+            @temp_index = temp_index
+            @visiting = Set.new
+            @visited = Set.new
+            @in_cycle = Set.new
+            @stack = []
+            @messages = {}
+          end
+
+          def detect
+            @temp_index.each_key { |tid| visit(tid) }
+            @messages
+          end
+
+          private
+
+          def visit(temp_id)
+            return if @visited.include?(temp_id)
+            return if @in_cycle.include?(temp_id)
+            return if @visiting.include?(temp_id)
+
+            @visiting.add(temp_id)
+            @stack.push(temp_id)
+
+            parent_temp = @temp_index[temp_id].payload.parent_temp_id
+            if parent_in_graph?(parent_temp)
+              if @visiting.include?(parent_temp)
+                record_cycle(parent_temp)
+              else
+                visit(parent_temp)
+              end
+            end
+
+            @stack.pop
+            @visiting.delete(temp_id)
+            @visited.add(temp_id)
+          end
+
+          def parent_in_graph?(parent_temp)
+            !Utils::Blank.blank?(parent_temp) && @temp_index.key?(parent_temp)
+          end
+
+          def record_cycle(parent_temp)
+            start_idx = @stack.index(parent_temp)
+            cycle_ids = @stack[start_idx..] + [parent_temp]
+            path_text = cycle_ids.map { |tid| display_name(tid) }.join(" -> ")
+
+            cycle_ids.each do |tid|
+              @in_cycle.add(tid)
+              @messages[tid] = "Cycle detected: #{path_text}"
+            end
+          end
+
+          def display_name(temp_id)
+            name = @temp_index[temp_id].payload.name.to_s
+            name.empty? ? temp_id : name
+          end
+        end
+      end
+    end
+  end
+end

data/lib/omnifocus_mcp/tools/operations/batch_add_items/param_builder.rb

@@ -0,0 +1,47 @@
+# frozen_string_literal: true
+
+require_relative "../../params"
+
+module OmnifocusMcp
+  module Tools
+    module Operations
+      class BatchAddItems
+        # Build typed param objects for nested add primitives from a batch item.
+        module ParamBuilder
+          class << self
+            def project(payload)
+              Params::AddProjectParams.new(
+                name: payload.name,
+                note: payload.note,
+                due_date: payload.due_date,
+                defer_date: payload.defer_date,
+                flagged: payload.flagged,
+                estimated_minutes: payload.estimated_minutes,
+                tags: payload.tags,
+                folder_name: payload.folder_name,
+                sequential: payload.sequential
+              )
+            end
+
+            def task(payload, parent_task_id:, project_name:)
+              Params::AddTaskParams.new(
+                name: payload.name,
+                note: payload.note,
+                due_date: payload.due_date,
+                defer_date: payload.defer_date,
+                planned_date: payload.planned_date,
+                flagged: payload.flagged,
+                estimated_minutes: payload.estimated_minutes,
+                tags: payload.tags,
+                project_name: project_name,
+                parent_task_id: parent_task_id,
+                parent_task_name: payload.parent_task_name,
+                hierarchy_level: payload.hierarchy_level
+              )
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/omnifocus_mcp/tools/operations/batch_add_items/planner.rb

@@ -0,0 +1,111 @@
+# frozen_string_literal: true
+
+require_relative "../../../utils/blank"
+require_relative "batch_item"
+require_relative "cycle_detector"
+
+module OmnifocusMcp
+  module Tools
+    module Operations
+      class BatchAddItems
+        # Resolves within-batch hierarchy metadata for batch add operations.
+        class Planner
+          Resolved = Data.define(:id, :type, :name)
+
+          def initialize(batch_items)
+            @batch_items = batch_items
+            @temp_resolved = {}
+          end
+
+          def prepare!
+            mark_cycle_failures(cycle_messages: cycle_detector.detect)
+            mark_unknown_parent_temp_id
+          end
+
+          # Stable order: by hierarchy_level (nil -> 0), then original index.
+          def processing_order
+            @batch_items.sort_by { |item| [item.payload.hierarchy_level || 0, item.index] }
+          end
+
+          # @return [Array(String?, String?, Boolean)] (parent_task_id,
+          #   project_name, ready). ready is false when the task depends on a
+          #   parent_temp_id that has not resolved yet, signalling a deferral.
+          def resolve_task_parent(payload)
+            parent_task_id = payload.parent_task_id
+            project_name = payload.project_name
+
+            return [parent_task_id, project_name, true] unless need_temp_resolution?(payload)
+
+            resolved = @temp_resolved[payload.parent_temp_id]
+            return [parent_task_id, project_name, false] unless resolved
+
+            if resolved.type == "project"
+              [parent_task_id, resolved.name, true]
+            else
+              [resolved.id, project_name, true]
+            end
+          end
+
+          def record_resolution(payload:, id:, type:)
+            temp_id = payload.temp_id
+            return if Utils::Blank.blank?(temp_id)
+
+            @temp_resolved[temp_id] = Resolved.new(id: id, type: type, name: payload.name)
+          end
+
+          def finalize_unresolved!
+            @batch_items.each do |item|
+              next unless item.pending?
+
+              item.fail!(unresolved_reason(item))
+            end
+          end
+
+          private
+
+          def temp_index
+            @temp_index ||= @batch_items.each_with_object({}) do |item, index|
+              temp = item.payload.temp_id
+              index[temp] = item unless Utils::Blank.blank?(temp)
+            end
+          end
+
+          def cycle_detector
+            CycleDetector.new(temp_index)
+          end
+
+          def mark_cycle_failures(cycle_messages:)
+            cycle_messages.each { |temp_id, message| temp_index[temp_id].fail!(message) }
+          end
+
+          def mark_unknown_parent_temp_id
+            @batch_items.each do |item|
+              next unless item.pending?
+
+              parent_temp = item.payload.parent_temp_id
+              next if Utils::Blank.blank?(parent_temp)
+              next if temp_index.key?(parent_temp)
+              next unless Utils::Blank.blank?(item.payload.parent_task_id)
+
+              item.fail!("Unknown parentTempId: #{parent_temp}")
+            end
+          end
+
+          def need_temp_resolution?(payload)
+            Utils::Blank.blank?(payload.parent_task_id) &&
+              !Utils::Blank.blank?(payload.parent_temp_id)
+          end
+
+          def unresolved_reason(item)
+            parent_temp = item.payload.parent_temp_id
+            if !Utils::Blank.blank?(parent_temp) && !@temp_resolved.key?(parent_temp)
+              "Unresolved parentTempId: #{parent_temp}"
+            else
+              "Unresolved dependency or cycle"
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/omnifocus_mcp/tools/operations/batch_add_items.rb

@@ -0,0 +1,149 @@
+# frozen_string_literal: true
+
+require_relative "../../infrastructure/script_runner"
+require_relative "../../result"
+require_relative "../params"
+require_relative "add_omnifocus_task"
+require_relative "add_project"
+require_relative "batch_add_items/planner"
+require_relative "batch_add_items/batch_item"
+require_relative "batch_add_items/bulk_executor"
+require_relative "batch_add_items/param_builder"
+
+module OmnifocusMcp
+  module Tools
+    module Operations
+      class BatchAddItems
+        class << self
+          def call(items, add_task: Operations::AddOmniFocusTask.method(:call),
+                   add_project: Operations::AddProject.method(:call),
+                   execute_applescript: Infrastructure::ScriptRunner.method(:execute_applescript),
+                   bulk_executor: BulkExecutor)
+            new(add_task:, add_project:, execute_applescript:, bulk_executor:).call(items)
+          end
+        end
+
+        def initialize(add_task:, add_project:, execute_applescript:, bulk_executor:)
+          @add_task = add_task
+          @add_project = add_project
+          @execute_applescript = execute_applescript
+          @bulk_executor = bulk_executor
+        end
+
+        def call(items)
+          batch_items = Array(items).map { |item| coerce_item(item) }
+                                    .then { |coerced| build_batch_items(coerced) }
+          planner = Planner.new(batch_items).tap(&:prepare!)
+
+          return OmnifocusMcp::Result.ok(batch_items.map(&:result)) if try_bulk_add!(batch_items:)
+
+          process_items(ordered: planner.processing_order, planner:)
+          planner.finalize_unresolved!
+
+          OmnifocusMcp::Result.ok(batch_items.map(&:result))
+        rescue StandardError => e
+          OmnifocusMcp.logger.warn("[batch_add_items] Error: #{e}")
+          OmnifocusMcp::Result.error(e.message || "Unknown error in batch_add_items")
+        end
+
+        private
+
+        attr_reader :add_task, :add_project, :execute_applescript, :bulk_executor
+
+        def try_bulk_add!(batch_items:)
+          bulk_results = bulk_executor.run(batch_items, execute_applescript:)
+          return false unless bulk_results
+
+          batch_items.select(&:pending?)
+                     .each_with_index do |batch_item, index|
+                       apply_bulk_result(batch_item, bulk_results[index])
+                     end
+          true
+        rescue StandardError => e
+          OmnifocusMcp.logger.warn("[batch_add_items] bulk path failed (#{e.message}); falling back to sequential")
+          false
+        end
+
+        def apply_bulk_result(batch_item, result)
+          if result.ok?
+            batch_item.succeed!(result.ok)
+          else
+            batch_item.fail!(result.error)
+          end
+        end
+
+        def coerce_item(item)
+          case item
+          when Params::BatchAddItemParams then item
+          when Hash then Params::BatchAddItemParams.from_hash(item)
+          else raise ArgumentError, "expected BatchAddItemParams or Hash, got #{item.class}"
+          end
+        end
+
+        def build_batch_items(items)
+          items.each_with_index.map { |payload, index| BatchItem.new(payload:, index:) }
+        end
+
+        def process_items(ordered:, planner:)
+          loop do
+            pending = ordered.select(&:pending?)
+            break if pending.empty?
+
+            process_pending_items(pending:, planner:)
+            break if ordered.count(&:pending?) == pending.length
+          end
+        end
+
+        def process_pending_items(pending:, planner:)
+          total = pending.length
+          pending.each_with_index do |batch_item, index|
+            OmnifocusMcp.logger.warn(
+              "[batch_add_items] sequential progress #{index + 1}/#{total}: #{batch_item.payload.name}"
+            )
+            process_single_item(batch_item:, planner:)
+          end
+        end
+
+        def process_single_item(batch_item:, planner:)
+          if batch_item.payload.type.to_s == "project"
+            run_project(batch_item:, planner:)
+          else
+            run_task(batch_item:, planner:)
+          end
+        rescue StandardError => e
+          batch_item.fail!(e.message || "Unknown error processing item")
+        end
+
+        def run_project(batch_item:, planner:)
+          payload = batch_item.payload
+          project_result = add_project.call(ParamBuilder.project(payload))
+
+          if project_result.error?
+            batch_item.fail!(project_result.error)
+          else
+            project_id = project_result.ok.project_id
+            batch_item.succeed!(project_id)
+            planner.record_resolution(payload:, id: project_id, type: "project")
+          end
+        end
+
+        def run_task(batch_item:, planner:)
+          payload = batch_item.payload
+          parent_task_id, project_name, ready = planner.resolve_task_parent(payload)
+          return unless ready
+
+          params = ParamBuilder.task(payload, parent_task_id:, project_name:)
+          task_result = add_task.call(params)
+
+          if task_result.error?
+            batch_item.fail!(task_result.error)
+          else
+            task_id = task_result.ok.task_id
+            batch_item.succeed!(task_id)
+            planner.record_resolution(payload:, id: task_id, type: "task")
+          end
+        end
+      end
+    end
+  end
+end

data/lib/omnifocus_mcp/tools/operations/batch_remove_items.rb

@@ -0,0 +1,49 @@
+# frozen_string_literal: true
+
+require_relative "../../result"
+require_relative "../params"
+require_relative "remove_item"
+
+module OmnifocusMcp
+  module Tools
+    module Operations
+      class BatchRemoveItems
+        class << self
+          def call(items, remove: Operations::RemoveItem.method(:call))
+            new(remove:).call(items)
+          end
+        end
+
+        def initialize(remove:)
+          @remove = remove
+        end
+
+        def call(items)
+          Array(items).map { |item| remove_one(coerce_item(item)) }
+                      .then { |results| OmnifocusMcp::Result.ok(results) }
+        rescue StandardError => e
+          OmnifocusMcp.logger.warn("[batch_remove_items] Error: #{e}")
+          OmnifocusMcp::Result.error(e.message || "Unknown error in batch_remove_items")
+        end
+
+        private
+
+        attr_reader :remove
+
+        def coerce_item(item)
+          case item
+          when Params::BatchRemoveItemParams then item
+          when Hash then Params::BatchRemoveItemParams.from_hash(item)
+          else raise ArgumentError, "expected BatchRemoveItemParams or Hash, got #{item.class}"
+          end
+        end
+
+        def remove_one(item)
+          remove.call(item)
+        rescue StandardError => e
+          OmnifocusMcp::Result.error(e.message || "Unknown error processing item")
+        end
+      end
+    end
+  end
+end

data/lib/omnifocus_mcp/tools/operations/database_stats.rb

@@ -0,0 +1,52 @@
+# frozen_string_literal: true
+
+require_relative "../../infrastructure/script_runner"
+require_relative "../../result"
+require_relative "../generators/database_stats"
+
+module OmnifocusMcp
+  module Tools
+    module Operations
+      class DatabaseStats
+        class << self
+          def get_database_stats(script_runner: Infrastructure::ScriptRunner)
+            new(script_runner:).get_database_stats
+          end
+
+          def get_changes_since(since, script_runner: Infrastructure::ScriptRunner)
+            new(script_runner:).get_changes_since(since)
+          end
+        end
+
+        def initialize(script_runner: Infrastructure::ScriptRunner, generator: Generators::DatabaseStats)
+          @script_runner = script_runner
+          @generator = generator
+        end
+
+        def get_database_stats
+          script_payload_result(script_runner.execute_omnifocus_source(generator.stats_script))
+        end
+
+        def get_changes_since(since)
+          iso = since.respond_to?(:utc) ? since.utc.iso8601 : since.to_s
+
+          script_payload_result(script_runner.execute_omnifocus_source(generator.changes_script(iso)))
+        end
+
+        private
+
+        attr_reader :script_runner, :generator
+
+        def script_payload_result(execution)
+          execution.and_then do |payload|
+            if payload.is_a?(Hash) && payload["error"]
+              Result.error(payload["error"])
+            else
+              Result.ok(payload)
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/omnifocus_mcp/tools/operations/edit_item.rb

@@ -0,0 +1,79 @@
+# frozen_string_literal: true
+
+require_relative "../../infrastructure/script_runner"
+require_relative "../../parsers/apple_script_envelope"
+require_relative "../../result"
+require_relative "../generators/edit_item"
+require_relative "../params"
+
+module OmnifocusMcp
+  module Tools
+    module Operations
+      class EditItem
+        Edited = Generators::EditItem::Edited
+
+        class << self
+          def call(params = nil, script_runner: Infrastructure::ScriptRunner, **kwargs)
+            merge_params(params, kwargs).then { new(script_runner:).call(it) }
+          end
+
+          def generate_apple_script(...) = Generators::EditItem.generate_apple_script(...)
+
+          private
+
+          def merge_params(params, kwargs)
+            return params || {} if kwargs.empty?
+
+            base = params.respond_to?(:to_h) ? params.to_h : params || {}
+            base.merge(kwargs)
+          end
+        end
+
+        def initialize(script_runner: Infrastructure::ScriptRunner, generator: Generators::EditItem)
+          @script_runner = script_runner
+          @generator = generator
+        end
+
+        def call(params)
+          params = Params::McpBoundary.coerce(Params::EditItemParams, params)
+          generator.generate_apple_script(params).then { |script| run_script(script) }
+        rescue StandardError => e
+          OmnifocusMcp.logger.warn("[edit_item] Error: #{e}")
+          OmnifocusMcp::Result.error(e.message || "Unknown error in edit_item")
+        end
+
+        private
+
+        attr_reader :script_runner, :generator
+
+        def run_script(script)
+          stdout, stderr, status = script_runner.execute_applescript(script)
+
+          OmnifocusMcp.logger.warn("[edit_item] AppleScript stderr: #{stderr}") if stderr && !stderr.empty?
+          return OmnifocusMcp::Result.error(applescript_run_failure(stderr:, status:)) unless status.success?
+
+          parse_result(stdout)
+        end
+
+        def parse_result(stdout)
+          Parsers::AppleScriptEnvelope.parse(stdout:, default_error: "Unknown error in edit_item") do |hash|
+            OmnifocusMcp::Result.ok(
+              Edited.new(
+                id: hash["id"],
+                name: hash["name"],
+                changed_properties: hash["changedProperties"]
+              )
+            )
+          end
+        end
+
+        def applescript_run_failure(stderr:, status:)
+          exit_code = status.respond_to?(:exitstatus) ? status.exitstatus : status
+          message = "osascript failed (exit #{exit_code})"
+          message += ": #{stderr.strip}" unless stderr.nil? || stderr.empty?
+          message
+        end
+      end
+    end
+  end
+end