omnifocus_mcp 1.0.0

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

@@ -0,0 +1,112 @@
+# frozen_string_literal: true
+
+require_relative "../../infrastructure/script_runner"
+require_relative "../../result"
+require_relative "../../utils/blank"
+require_relative "../generators/perspective_view"
+require_relative "../params"
+
+module OmnifocusMcp
+  module Tools
+    module Operations
+      class GetPerspectiveView
+        DEFAULT_LIMIT = 100
+
+        class << self
+          def call(params = nil, script_runner: Infrastructure::ScriptRunner, **kwargs)
+            params = merge_params(params, kwargs)
+            new(script_runner:).call(params)
+          end
+
+          def normalize_limit(value) = new.normalize_limit(value)
+
+          def classify_response(response:, fields:, limit:)
+            new.classify_response(response:, fields:, limit:)
+          end
+
+          def shape_items(items:, fields:, limit:)
+            new.shape_items(items:, fields:, limit:)
+          end
+
+          def project_fields(items:, fields:)
+            new.project_fields(items:, fields:)
+          end
+
+          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::PerspectiveView)
+          @script_runner = script_runner
+          @generator = generator
+        end
+
+        def call(params)
+          Params::McpBoundary.coerce(Params::GetPerspectiveViewParams, params).then do |params|
+            perspective_name = params.perspective_name.to_s
+            return OmnifocusMcp::Result.error("Perspective name is required") if Utils::Blank.blank?(perspective_name)
+
+            limit = normalize_limit(params.limit)
+            fields = params.fields
+            args = generator.args(perspective_name:, limit:)
+
+            script_runner.execute_omnifocus_script(generator.script_path, args:)
+                         .and_then { |response| classify_response(response:, fields:, limit:) }
+          end
+        rescue StandardError => e
+          OmnifocusMcp.logger.warn("[get_perspective_view] Error: #{e}")
+          OmnifocusMcp::Result.error(e.message || "Unknown error occurred")
+        end
+
+        def normalize_limit(value)
+          return DEFAULT_LIMIT if value.nil?
+          return value if value.is_a?(Integer) && value.positive?
+
+          DEFAULT_LIMIT
+        end
+
+        def classify_response(response:, fields:, limit:)
+          shape = response.is_a?(Hash) ? response.transform_keys(&:to_sym) : nil
+
+          case shape
+          in { error: String => msg }
+            OmnifocusMcp::Result.error(msg)
+          in { items: Array => items }
+            OmnifocusMcp::Result.ok(shape_items(items:, fields:, limit:))
+          in Hash
+            OmnifocusMcp::Result.ok([])
+          in nil
+            OmnifocusMcp::Result.error("Unexpected response from getPerspectiveView.js: #{response.inspect}")
+          end
+        end
+
+        def shape_items(items:, fields:, limit:)
+          items = project_fields(items:, fields:) if fields && !fields.empty?
+          items = items.first(limit) if items.length > limit
+          items
+        end
+
+        def project_fields(items:, fields:)
+          string_fields = fields.map(&:to_s)
+          items.map do |item|
+            next item unless item.is_a?(Hash)
+
+            string_fields.each_with_object({}) do |field, projected|
+              projected[field] = item[field] if item.key?(field)
+            end
+          end
+        end
+
+        private
+
+        attr_reader :script_runner, :generator
+      end
+    end
+  end
+end

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

@@ -0,0 +1,85 @@
+# frozen_string_literal: true
+
+require_relative "../../infrastructure/script_runner"
+require_relative "../../result"
+require_relative "../generators/list_perspectives"
+require_relative "../params"
+
+module OmnifocusMcp
+  module Tools
+    module Operations
+      class ListPerspectives
+        class << self
+          def call(params = nil, script_runner: Infrastructure::ScriptRunner, **kwargs)
+            merge_params(params, kwargs).then { |params| new(script_runner:).call(params) }
+          end
+
+          def classify_response(response:, include_built_in:, include_custom:)
+            new.classify_response(response:, include_built_in:, include_custom:)
+          end
+
+          def filter_perspectives(perspectives:, include_built_in:, include_custom:)
+            new.filter_perspectives(perspectives:, include_built_in:, include_custom:)
+          end
+
+          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::ListPerspectives)
+          @script_runner = script_runner
+          @generator = generator
+        end
+
+        def call(params = {})
+          params = Params::McpBoundary.coerce(Params::ListPerspectivesParams, params)
+
+          script_runner.execute_omnifocus_script(generator.script_path)
+                       .and_then do |response|
+            classify_response(
+              response:,
+              include_built_in: params.include_built_in,
+              include_custom: params.include_custom
+            )
+          end
+        rescue StandardError => e
+          OmnifocusMcp.logger.warn("[list_perspectives] Error: #{e}")
+          OmnifocusMcp::Result.error(e.message || "Unknown error occurred")
+        end
+
+        def classify_response(response:, include_built_in:, include_custom:)
+          shape = response.is_a?(Hash) ? response.transform_keys(&:to_sym) : nil
+
+          case shape
+          in { error: String => msg }
+            OmnifocusMcp::Result.error(msg)
+          in { perspectives: Array => perspectives }
+            OmnifocusMcp::Result.ok(
+              filter_perspectives(perspectives:, include_built_in:, include_custom:)
+            )
+          in Hash
+            OmnifocusMcp::Result.ok([])
+          in nil
+            OmnifocusMcp::Result.error("Unexpected response from listPerspectives.js: #{response.inspect}")
+          end
+        end
+
+        def filter_perspectives(perspectives:, include_built_in:, include_custom:)
+          perspectives = perspectives.reject { |perspective| perspective["type"] == "builtin" } unless include_built_in
+          perspectives = perspectives.reject { |perspective| perspective["type"] == "custom"  } unless include_custom
+          perspectives
+        end
+
+        private
+
+        attr_reader :script_runner, :generator
+      end
+    end
+  end
+end

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

@@ -0,0 +1,80 @@
+# frozen_string_literal: true
+
+require_relative "../../infrastructure/script_runner"
+require_relative "../../result"
+require_relative "../generators/list_tags"
+require_relative "../params"
+
+module OmnifocusMcp
+  module Tools
+    module Operations
+      class ListTags
+        class << self
+          def call(params = nil, script_runner: Infrastructure::ScriptRunner, **kwargs)
+            params = merge_params(params, kwargs)
+            new(script_runner:).call(params)
+          end
+
+          def classify_response(response:, include_dropped:)
+            new.classify_response(response:, include_dropped:)
+          end
+
+          def filter_tags(tags:, include_dropped:)
+            new.filter_tags(tags:, include_dropped:)
+          end
+
+          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::ListTags)
+          @script_runner = script_runner
+          @generator = generator
+        end
+
+        def call(params = {})
+          params = Params::McpBoundary.coerce(Params::ListTagsParams, params)
+
+          script_runner.execute_omnifocus_script(generator.script_path)
+                       .and_then do |response|
+            classify_response(response:, include_dropped: params.include_dropped)
+          end
+        rescue StandardError => e
+          OmnifocusMcp.logger.warn("[list_tags] Error: #{e}")
+          OmnifocusMcp::Result.error(e.message || "Unknown error occurred")
+        end
+
+        def classify_response(response:, include_dropped:)
+          shape = response.is_a?(Hash) ? response.transform_keys(&:to_sym) : nil
+
+          case shape
+          in { error: String => msg }
+            OmnifocusMcp::Result.error(msg)
+          in { tags: Array => tags }
+            OmnifocusMcp::Result.ok(filter_tags(tags:, include_dropped:))
+          in Hash
+            OmnifocusMcp::Result.ok([])
+          in nil
+            OmnifocusMcp::Result.error("Unexpected response from listTags.js: #{response.inspect}")
+          end
+        end
+
+        def filter_tags(tags:, include_dropped:)
+          return tags if include_dropped
+
+          tags.select { |tag| tag["active"] }
+        end
+
+        private
+
+        attr_reader :script_runner, :generator
+      end
+    end
+  end
+end

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

@@ -0,0 +1,74 @@
+# frozen_string_literal: true
+
+require_relative "../../infrastructure/script_runner"
+require_relative "../../result"
+require_relative "../generators/query_omnifocus"
+require_relative "../params"
+
+module OmnifocusMcp
+  module Tools
+    module Operations
+      class QueryOmnifocus
+        Match = Data.define(:items, :count)
+
+        class << self
+          def call(params = nil, script_runner: Infrastructure::ScriptRunner, **kwargs)
+            merge_params(params, kwargs).then { new(script_runner:).call(it) }
+          end
+
+          def classify_response(...) = new.classify_response(...)
+          def build_match(...) = new.build_match(...)
+          def generate_query_script(...) = Generators::QueryOmnifocus.generate_query_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::QueryOmnifocus)
+          @script_runner = script_runner
+          @generator = generator
+        end
+
+        def call(params)
+          params = Params::McpBoundary.coerce(Params::QueryOmnifocusParams, params)
+          generator.generate_query_script(params).then do |script|
+            script_runner.execute_omnifocus_source(script)
+                         .and_then { |response| classify_response(response:, summary: params.summary == true) }
+          end
+        rescue StandardError => e
+          OmnifocusMcp.logger.warn("[query_omnifocus] Error: #{e}")
+          OmnifocusMcp::Result.error(e.message || "Unknown error occurred")
+        end
+
+        def classify_response(response:, summary:)
+          shape = response.is_a?(Hash) ? response.transform_keys(&:to_sym) : nil
+
+          case shape
+          in { error: String => msg }
+            OmnifocusMcp::Result.error(msg)
+          in { items: Array => items, count: Integer => count }
+            OmnifocusMcp::Result.ok(build_match(items:, count:, summary: summary))
+          in { count: Integer => count }
+            OmnifocusMcp::Result.ok(Match.new(items: nil, count: count))
+          in Hash
+            OmnifocusMcp::Result.ok(Match.new(items: nil, count: nil))
+          in nil
+            OmnifocusMcp::Result.error("Unexpected response from queryOmnifocus: #{response.inspect}")
+          end
+        end
+
+        def build_match(items:, count:, summary:) = Match.new(items: summary ? nil : items, count: count)
+
+        private
+
+        attr_reader :script_runner, :generator
+      end
+    end
+  end
+end

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

@@ -0,0 +1,63 @@
+# frozen_string_literal: true
+
+require_relative "../../infrastructure/script_runner"
+require_relative "../../result"
+require_relative "../generators/query_omnifocus_debug"
+
+module OmnifocusMcp
+  module Tools
+    module Operations
+      class QueryOmnifocusDebug
+        ENTITIES = %w[task project folder].freeze
+        private_constant :ENTITIES
+
+        class << self
+          def call(entity, script_runner: Infrastructure::ScriptRunner)
+            new(script_runner:).call(entity)
+          end
+
+          def generate_debug_script(...) = Generators::QueryOmnifocusDebug.generate_debug_script(...)
+        end
+
+        def initialize(script_runner: Infrastructure::ScriptRunner, generator: Generators::QueryOmnifocusDebug)
+          @script_runner = script_runner
+          @generator = generator
+        end
+
+        def call(entity)
+          normalized = entity.to_s
+          return OmnifocusMcp::Result.error(unknown_entity_message(normalized)) unless ENTITIES.include?(normalized)
+
+          generator.generate_debug_script(normalized).then do |script|
+            script_runner.execute_omnifocus_source(script)
+                         .and_then { |response| classify_response(response) }
+          end
+        rescue StandardError => e
+          OmnifocusMcp.logger.warn("[query_omnifocus_debug] Error: #{e}")
+          OmnifocusMcp::Result.error(e.message || "Unknown error in query_omnifocus_debug")
+        end
+
+        private
+
+        attr_reader :script_runner, :generator
+
+        def classify_response(response)
+          shape = response.is_a?(Hash) ? response.transform_keys(&:to_sym) : nil
+
+          case shape
+          in { error: String => msg }
+            OmnifocusMcp::Result.error(msg)
+          in Hash
+            OmnifocusMcp::Result.ok(response)
+          in nil
+            OmnifocusMcp::Result.error("Unexpected response from query_omnifocus_debug: #{response.inspect}")
+          end
+        end
+
+        def unknown_entity_message(entity)
+          "Unknown entity: #{entity.inspect}. Must be one of #{ENTITIES.join(", ")}"
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,75 @@
+# frozen_string_literal: true
+
+require_relative "../../infrastructure/script_runner"
+require_relative "../../parsers/apple_script_envelope"
+require_relative "../../result"
+require_relative "../generators/remove_item"
+require_relative "../params"
+
+module OmnifocusMcp
+  module Tools
+    module Operations
+      class RemoveItem
+        Removed = Data.define(:id, :name)
+
+        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(params = nil, **)
+            Generators::RemoveItem.generate_apple_script(params, **)
+          end
+
+          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::RemoveItem)
+          @script_runner = script_runner
+          @generator = generator
+        end
+
+        def call(params)
+          params = Params::McpBoundary.coerce(Params::RemoveItemParams, params)
+          generator.generate_apple_script(params).then { |script| run_script(script) }
+        rescue StandardError => e
+          OmnifocusMcp.logger.warn("[remove_item] Error: #{e}")
+          OmnifocusMcp::Result.error(e.message || "Unknown error in remove_item")
+        end
+
+        private
+
+        attr_reader :script_runner, :generator
+
+        def run_script(script)
+          stdout, stderr, status = script_runner.execute_applescript(script)
+
+          OmnifocusMcp.logger.warn("[remove_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 remove_item") do |hash|
+            OmnifocusMcp::Result.ok(Removed.new(id: hash["id"], name: hash["name"]))
+          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

data/lib/omnifocus_mcp/tools/operations.rb

@@ -0,0 +1,8 @@
+# frozen_string_literal: true
+
+module OmnifocusMcp
+  module Tools
+    module Operations
+    end
+  end
+end

data/lib/omnifocus_mcp/tools/params/mcp_boundary.rb

@@ -0,0 +1,41 @@
+# frozen_string_literal: true
+
+require_relative "../definitions/key_normalizer"
+
+module OmnifocusMcp
+  module Tools
+    module Params
+      # Builds {Data.define} param structs from MCP wire args or snake_case Hashes.
+      module McpBoundary
+        class << self
+          # @param klass [Data] struct class whose +members+ list snake_case fields
+          # @param args [Hash] raw MCP arguments (camelCase Symbol keys)
+          # @param deep [Boolean] recurse into nested Hashes and Arrays of Hashes
+          def build(klass, args, deep: false)
+            snake = Definitions::KeyNormalizer.snake_keys(args, deep: deep)
+            from_snake_hash(klass, snake)
+          end
+
+          # @param klass [Data]
+          # @param hash [Hash] snake_case Symbol keys (e.g. from tests or resources)
+          def from_hash(klass, hash)
+            from_snake_hash(klass, hash || {})
+          end
+
+          def from_snake_hash(klass, snake)
+            klass.new(**klass.members.to_h { |member| [member, snake[member]] })
+          end
+
+          # Accept a param struct or a snake_case Hash (e.g. specs, script helpers).
+          def coerce(klass, value)
+            case value
+            when klass then value
+            when Hash then klass.from_hash(value)
+            else raise ArgumentError, "expected #{klass.name}, got #{value.class}"
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/omnifocus_mcp/tools/params.rb

@@ -0,0 +1,106 @@
+# frozen_string_literal: true
+
+require_relative "params/mcp_boundary"
+
+module OmnifocusMcp
+  module Tools
+    # Typed input objects for tool primitives. MCP tools build these via
+    # {.from_mcp}; other callers (resources, integration specs) use {.from_hash}.
+    module Params
+      AddTaskParams = Data.define(
+        :name, :note, :due_date, :defer_date, :planned_date,
+        :flagged, :estimated_minutes, :tags, :project_name,
+        :parent_task_id, :parent_task_name, :hierarchy_level
+      ) do
+        def self.from_mcp(args) = McpBoundary.build(self, args)
+        def self.from_hash(hash) = McpBoundary.from_hash(self, hash)
+      end
+
+      AddProjectParams = Data.define(
+        :name, :note, :due_date, :defer_date, :flagged,
+        :estimated_minutes, :tags, :folder_name, :sequential
+      ) do
+        def self.from_mcp(args) = McpBoundary.build(self, args)
+        def self.from_hash(hash) = McpBoundary.from_hash(self, hash)
+      end
+
+      EditItemParams = Data.define(
+        :id, :name, :item_type, :new_name, :new_note,
+        :new_due_date, :new_defer_date, :new_planned_date, :new_flagged,
+        :new_estimated_minutes, :new_status, :add_tags, :remove_tags,
+        :replace_tags, :new_project_name, :new_sequential, :new_folder_name,
+        :new_project_status
+      ) do
+        def self.from_mcp(args) = McpBoundary.build(self, args)
+        def self.from_hash(hash) = McpBoundary.from_hash(self, hash)
+      end
+
+      RemoveItemParams = Data.define(:id, :name, :item_type) do
+        def self.from_mcp(args) = McpBoundary.build(self, args)
+        def self.from_hash(hash) = McpBoundary.from_hash(self, hash)
+      end
+
+      QueryOmnifocusParams = Data.define(
+        :entity, :filters, :fields, :limit, :sort_by, :sort_order,
+        :include_completed, :format, :summary
+      ) do
+        def self.from_mcp(args) = McpBoundary.build(self, args, deep: true)
+        def self.from_hash(hash) = McpBoundary.from_hash(self, hash)
+      end
+
+      BatchAddItemParams = Data.define(
+        :type, :name, :note, :due_date, :defer_date, :planned_date,
+        :flagged, :estimated_minutes, :tags, :project_name, :parent_task_id,
+        :parent_task_name, :temp_id, :parent_temp_id, :hierarchy_level,
+        :folder_name, :sequential
+      ) do
+        def self.from_mcp(args) = McpBoundary.build(self, args)
+        def self.from_hash(hash) = McpBoundary.from_hash(self, hash)
+      end
+
+      BatchRemoveItemParams = Data.define(:id, :name, :item_type) do
+        def self.from_mcp(args) = McpBoundary.build(self, args)
+        def self.from_hash(hash) = McpBoundary.from_hash(self, hash)
+      end
+
+      ListPerspectivesParams = Data.define(:include_built_in, :include_custom) do
+        def self.from_mcp(args)
+          new(
+            include_built_in: args.fetch(:includeBuiltIn, true),
+            include_custom: args.fetch(:includeCustom, true)
+          )
+        end
+
+        def self.from_hash(hash)
+          new(
+            include_built_in: hash.fetch(:include_built_in, true),
+            include_custom: hash.fetch(:include_custom, true)
+          )
+        end
+      end
+
+      ListTagsParams = Data.define(:include_dropped) do
+        def self.from_mcp(args) = new(include_dropped: args[:includeDropped] || false)
+        def self.from_hash(hash) = new(include_dropped: hash.fetch(:include_dropped, false))
+      end
+
+      GetPerspectiveViewParams = Data.define(:perspective_name, :limit, :fields) do
+        def self.from_mcp(args)
+          new(
+            perspective_name: args[:perspectiveName],
+            limit: args[:limit],
+            fields: args[:fields]
+          )
+        end
+
+        def self.from_hash(hash)
+          new(
+            perspective_name: hash[:perspective_name],
+            limit: hash[:limit],
+            fields: hash[:fields]
+          )
+        end
+      end
+    end
+  end
+end