omnifocus_mcp 1.0.0

data/lib/omnifocus_mcp/tools/definitions/batch_remove_items_tool.rb

@@ -0,0 +1,68 @@
+# frozen_string_literal: true
+
+require "fast_mcp"
+
+require_relative "mcp_envelope"
+require_relative "operation_factory"
+require_relative "../messages/batch_remove_items"
+require_relative "../operations/batch_remove_items"
+require_relative "../params"
+require_relative "../presenters/batch_report"
+require_relative "../../utils/blank"
+
+module OmnifocusMcp
+  module Tools
+    module Definitions
+      # `FastMcp::Tool` for `batch_remove_items`.
+      class BatchRemoveItemsTool < FastMcp::Tool
+        tool_name "batch_remove_items"
+        description "Remove multiple tasks or projects from OmniFocus in a single operation"
+
+        arguments do
+          required(:items).array(:hash) do
+            optional(:id).filled(:string).description("The ID of the task or project to remove")
+            optional(:name).filled(:string).description(
+              "The name of the task or project to remove (as fallback if ID not provided)"
+            )
+            required(:itemType).filled(included_in?: %w[task project])
+                               .description("Type of item to remove ('task' or 'project')")
+          end.description("Array of items (tasks or projects) to remove")
+        end
+
+        extend OperationFactory
+
+        default_operation_factory { Operations::BatchRemoveItems.method(:call) }
+
+        def call(**args)
+          items = Array(args[:items]).map { |item| Params::BatchRemoveItemParams.from_mcp(item) }
+          if any_missing_identifier?(items)
+            return McpEnvelope::ToolReply.failure(Messages::BatchRemoveItems.missing_identifier).to_envelope
+          end
+
+          McpEnvelope.safely("processing batch removal") do
+            operation.call(items).fold(
+              on_ok: ->(results) { success_reply(results, items) },
+              on_error: ->(err) { McpEnvelope::ToolReply.failure(Presenters::BatchReport.format_failure(err)) }
+            )
+          end
+        end
+
+        private
+
+        def any_missing_identifier?(items) = items.any? { |i| Utils::Blank.blank?(i.id, i.name) }
+
+        def success_reply(results, items)
+          text = Presenters::BatchReport.format_success(
+            past_tense: "removed", failure_verb: "remove", results:, items:
+          ) { |item_result, item| Presenters::BatchReport.remove_detail(item_result, item) }
+
+          if Presenters::BatchReport.all_failed?(results)
+            McpEnvelope::ToolReply.failure(text)
+          else
+            McpEnvelope::ToolReply.success(text)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/omnifocus_mcp/tools/definitions/date_formatter.rb

@@ -0,0 +1,45 @@
+# frozen_string_literal: true
+
+require "date"
+
+require_relative "../../utils/blank"
+require_relative "../../utils/iso_date"
+
+module OmnifocusMcp
+  module Tools
+    module Definitions
+      module DateFormatter
+        class << self
+          def format_date(iso, style:)
+            return "" if Utils::Blank.blank?(iso)
+
+            case style
+            when :locale  then format_parsed(iso) { |d| us_short_date(d) }
+            when :compact then format_parsed(iso) { |d| us_compact_date(d) }
+            when :iso     then Utils::IsoDate.to_date_only(iso)
+            else raise ArgumentError, "Unknown date style: #{style.inspect}"
+            end
+          end
+
+          private
+
+          def us_short_date(date)
+            # TODO: Fix the formatting. Make Rubocop happy
+            format("%d/%d/%d", date.month, date.day, date.year)
+          end
+
+          def us_compact_date(date)
+            # TODO: Fix the formatting. Make Rubocop happy
+            format("%d/%d", date.month, date.day)
+          end
+
+          def format_parsed(iso)
+            yield Date.parse(iso.to_s)
+          rescue ArgumentError
+            ""
+          end
+        end
+      end
+    end
+  end
+end

data/lib/omnifocus_mcp/tools/definitions/edit_item_tool.rb

@@ -0,0 +1,87 @@
+# frozen_string_literal: true
+
+require "fast_mcp"
+
+require_relative "mcp_envelope"
+require_relative "operation_factory"
+require_relative "../messages/edit_item"
+require_relative "../operations/edit_item"
+require_relative "../params"
+require_relative "../../utils/blank"
+
+module OmnifocusMcp
+  module Tools
+    module Definitions
+      # `FastMcp::Tool` for `edit_item`.
+      class EditItemTool < FastMcp::Tool
+        tool_name "edit_item"
+        description "Edit a task or project in OmniFocus"
+
+        # rubocop:disable Metrics/BlockLength
+        arguments do
+          optional(:id).filled(:string).description("The ID of the task or project to edit")
+          optional(:name).filled(:string)
+                         .description("The name of the task or project to edit (as fallback if ID not provided)")
+          required(:itemType).filled(included_in?: %w[task project])
+                             .description("Type of item to edit ('task' or 'project')")
+
+          optional(:newName).filled(:string).description("New name for the item")
+          optional(:newNote).filled(:string).description("New note for the item")
+          optional(:newDueDate).maybe(:string).description(
+            "New due date in ISO format (YYYY-MM-DD or full ISO date); set to empty string to clear"
+          )
+          optional(:newDeferDate).maybe(:string).description(
+            "New defer date in ISO format (YYYY-MM-DD or full ISO date); set to empty string to clear"
+          )
+          optional(:newPlannedDate).maybe(:string).description(
+            "New planned date in ISO format (YYYY-MM-DD or full ISO date); set to empty string to clear (tasks only)"
+          )
+          optional(:newFlagged).filled(:bool)
+                               .description("Set flagged status (set to false for no flag, true for flag)")
+          optional(:newEstimatedMinutes).filled(:integer).description("New estimated minutes")
+
+          optional(:newStatus).filled(included_in?: %w[incomplete completed dropped skipped]).description(
+            "New status for tasks (incomplete, completed, dropped, skipped). 'skipped' only works on " \
+            "repeating tasks \u2014 it completes the current occurrence to trigger the next repeat, then " \
+            "drops the completed instance."
+          )
+          optional(:addTags).array(:string).description("Tags to add to the task")
+          optional(:removeTags).array(:string).description("Tags to remove from the task")
+          optional(:replaceTags).array(:string).description("Tags to replace all existing tags with")
+          optional(:newProjectName).maybe(:string).description(
+            "Move this task to a different project by name or folder path (e.g. 'My Project' or " \
+            "'Work/My Project' to disambiguate). Pass an empty string or 'inbox' to move the task to " \
+            "the inbox. (tasks only)"
+          )
+
+          optional(:newSequential).filled(:bool).description("Whether the project should be sequential")
+          optional(:newFolderName).filled(:string).description("New folder to move the project to")
+          optional(:newProjectStatus).filled(included_in?: %w[active completed dropped onHold])
+                                     .description("New status for projects")
+        end
+        # rubocop:enable Metrics/BlockLength
+
+        extend OperationFactory
+
+        default_operation_factory { Operations::EditItem.method(:call) }
+
+        def call(**args)
+          if missing_identifier?(args)
+            return McpEnvelope::ToolReply.failure(Messages::EditItem.missing_identifier).to_envelope
+          end
+
+          McpEnvelope.safely("updating #{args[:itemType]}") do
+            operation.call(Params::EditItemParams.from_mcp(args)).fold(
+              on_ok: ->(edited) { McpEnvelope::ToolReply.success(Messages::EditItem.success(args, edited)) },
+              on_error: ->(err) { McpEnvelope::ToolReply.failure(Messages::EditItem.failure(args, err)) }
+            )
+          end
+        end
+
+        private
+
+        def missing_identifier?(args) = Utils::Blank.blank?(args[:id], args[:name])
+      end
+    end
+  end
+end

data/lib/omnifocus_mcp/tools/definitions/get_perspective_view_tool.rb

@@ -0,0 +1,57 @@
+# frozen_string_literal: true
+
+require "fast_mcp"
+
+require_relative "mcp_envelope"
+require_relative "operation_factory"
+require_relative "../messages/list_tools"
+require_relative "../operations/get_perspective_view"
+require_relative "../params"
+require_relative "../presenters/perspective_view"
+
+module OmnifocusMcp
+  module Tools
+    module Definitions
+      # `FastMcp::Tool` for `get_perspective_view`.
+      class GetPerspectiveViewTool < FastMcp::Tool
+        tool_name "get_perspective_view"
+        description "Get the items visible in a specific OmniFocus perspective. " \
+                    "Shows what tasks and projects are displayed when viewing that perspective"
+
+        arguments do
+          required(:perspectiveName).filled(:string).description(
+            "Name of the perspective to view (e.g., 'Inbox', 'Projects', 'Flagged', or custom perspective name)"
+          )
+          optional(:limit).filled(:integer).description("Maximum number of items to return. Default: 100")
+          optional(:fields).array(:string).description(
+            "Specific fields to include in the response. Reduces response size. Available fields: " \
+            "id, name, note, flagged, dueDate, deferDate, completionDate, taskStatus, projectName, " \
+            "tagNames, estimatedMinutes"
+          )
+        end
+
+        extend OperationFactory
+
+        default_operation_factory { Operations::GetPerspectiveView.method(:call) }
+
+        def call(**args)
+          McpEnvelope.safely("getting perspective view") do
+            params = Params::GetPerspectiveViewParams.from_mcp(args)
+            limit = Operations::GetPerspectiveView.normalize_limit(params.limit)
+            # TODO: I don't like this nested function call
+            operation.call(
+              Params::GetPerspectiveViewParams.new(
+                perspective_name: params.perspective_name, limit: limit, fields: params.fields
+              )
+            ).fold(
+              on_ok: lambda do |items|
+                McpEnvelope::ToolReply.success(Presenters::PerspectiveView.format(args[:perspectiveName], items, limit))
+              end,
+              on_error: ->(err) { McpEnvelope::ToolReply.failure(Messages::ListTools.perspective_view_failure(err)) }
+            )
+          end
+        end
+      end
+    end
+  end
+end

data/lib/omnifocus_mcp/tools/definitions/key_normalizer.rb

@@ -0,0 +1,30 @@
+# frozen_string_literal: true
+
+module OmnifocusMcp
+  module Tools
+    module Definitions
+      module KeyNormalizer
+        class << self
+          def snake_keys(obj, deep: false)
+            case obj
+            when Hash
+              obj.each_with_object({}) do |(k, v), out|
+                out[snake_case_key(k)] = deep ? snake_keys(v, deep: true) : v
+              end
+            when Array
+              deep ? obj.map { |item| snake_keys(item, deep: true) } : obj
+            else
+              obj
+            end
+          end
+
+          def snake_case_key(key)
+            return key unless key.is_a?(Symbol) || key.is_a?(String)
+
+            key.to_s.gsub(/([a-z\d])([A-Z])/, '\1_\2').downcase.to_sym
+          end
+        end
+      end
+    end
+  end
+end

data/lib/omnifocus_mcp/tools/definitions/list_perspectives_tool.rb

@@ -0,0 +1,47 @@
+# frozen_string_literal: true
+
+require "fast_mcp"
+
+require_relative "mcp_envelope"
+require_relative "operation_factory"
+require_relative "../messages/list_tools"
+require_relative "../operations/list_perspectives"
+require_relative "../params"
+require_relative "../presenters/list_perspectives"
+
+module OmnifocusMcp
+  module Tools
+    module Definitions
+      # `FastMcp::Tool` for `list_perspectives`.
+      class ListPerspectivesTool < FastMcp::Tool
+        tool_name "list_perspectives"
+        description "List all available perspectives in OmniFocus, including built-in perspectives " \
+                    "(Inbox, Projects, Tags, etc.) and custom perspectives (Pro feature)"
+
+        arguments do
+          optional(:includeBuiltIn).filled(:bool).description(
+            "Include built-in perspectives (Inbox, Projects, Tags, etc.). Default: true"
+          )
+          optional(:includeCustom).filled(:bool).description("Include custom perspectives (Pro feature). Default: true")
+        end
+
+        extend OperationFactory
+
+        default_operation_factory { Operations::ListPerspectives.method(:call) }
+
+        def call(**args)
+          McpEnvelope.safely("listing perspectives") do
+            params = Params::ListPerspectivesParams.from_mcp(args)
+
+            operation.call(params).fold(
+              on_ok: lambda { |perspectives|
+                McpEnvelope::ToolReply.success(Presenters::ListPerspectives.format(perspectives))
+              },
+              on_error: ->(err) { McpEnvelope::ToolReply.failure(Messages::ListTools.list_perspectives_failure(err)) }
+            )
+          end
+        end
+      end
+    end
+  end
+end

data/lib/omnifocus_mcp/tools/definitions/list_tags_tool.rb

@@ -0,0 +1,42 @@
+# frozen_string_literal: true
+
+require "fast_mcp"
+
+require_relative "mcp_envelope"
+require_relative "operation_factory"
+require_relative "../messages/list_tools"
+require_relative "../operations/list_tags"
+require_relative "../params"
+require_relative "../presenters/list_tags"
+
+module OmnifocusMcp
+  module Tools
+    module Definitions
+      # `FastMcp::Tool` for `list_tags`.
+      class ListTagsTool < FastMcp::Tool
+        tool_name "list_tags"
+        description "List all tags in OmniFocus with their hierarchy. " \
+                    "Useful for discovering available tags before creating or editing tasks."
+
+        arguments do
+          optional(:includeDropped).filled(:bool).description("Include dropped/inactive tags. Default: false")
+        end
+
+        extend OperationFactory
+
+        default_operation_factory { Operations::ListTags.method(:call) }
+
+        def call(**args)
+          McpEnvelope.safely("listing tags") do
+            params = Params::ListTagsParams.from_mcp(args)
+
+            operation.call(params).fold(
+              on_ok: ->(tags) { McpEnvelope::ToolReply.success(Presenters::ListTags.format(tags)) },
+              on_error: ->(err) { McpEnvelope::ToolReply.failure(Messages::ListTools.list_tags_failure(err)) }
+            )
+          end
+        end
+      end
+    end
+  end
+end

data/lib/omnifocus_mcp/tools/definitions/mcp_envelope.rb

@@ -0,0 +1,31 @@
+# frozen_string_literal: true
+
+module OmnifocusMcp
+  module Tools
+    module Definitions
+      module McpEnvelope
+        ToolReply = Data.define(:text, :error) do
+          def to_envelope = error ? McpEnvelope.text_error(text) : McpEnvelope.text_result(text)
+
+          def self.success(text) = new(text: text, error: false)
+          def self.failure(text) = new(text: text, error: true)
+        end
+
+        class << self
+          def text_result(text) = { content: [{ type: "text", text: text }] }
+
+          def text_error(text) = { content: [{ type: "text", text: text }], isError: true }
+
+          def safely(scope, custom_message: nil)
+            result = yield
+            result.is_a?(ToolReply) ? result.to_envelope : result
+          rescue StandardError => e
+            default = "Error #{scope}: #{e.message}"
+            OmnifocusMcp.logger.warn(default)
+            text_error(custom_message || default)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/omnifocus_mcp/tools/definitions/operation_factory.rb

@@ -0,0 +1,33 @@
+# frozen_string_literal: true
+
+module OmnifocusMcp
+  module Tools
+    module Definitions
+      module OperationFactory
+        def self.extended(base)
+          base.include InstanceMethods
+        end
+
+        def default_operation_factory(&factory)
+          @default_operation_factory = factory
+        end
+
+        def operation_factory
+          @operation_factory || @default_operation_factory
+        end
+
+        def operation_factory=(factory)
+          @operation_factory = factory
+        end
+
+        module InstanceMethods
+          private
+
+          def operation
+            self.class.operation_factory.call
+          end
+        end
+      end
+    end
+  end
+end

data/lib/omnifocus_mcp/tools/definitions/query_omnifocus_tool.rb

@@ -0,0 +1,187 @@
+# frozen_string_literal: true
+
+require "fast_mcp"
+
+require_relative "mcp_envelope"
+require_relative "operation_factory"
+require_relative "../operations/query_omnifocus"
+require_relative "../params"
+require_relative "../presenters/query_reply"
+require_relative "../query_statuses"
+require_relative "../../utils/date_filter"
+
+module OmnifocusMcp
+  module Tools
+    module Definitions
+      # `FastMcp::Tool` for `query_omnifocus`.
+      class QueryOmnifocusTool < FastMcp::Tool
+        tool_name "query_omnifocus"
+        description "Efficiently query OmniFocus database with powerful filters. " \
+                    "Get specific tasks, projects, or folders without loading the entire database. " \
+                    "Supports filtering by project, tags, status, due dates, and more."
+
+        DATE_FILTER_FIELDS = %i[due_within deferred_until planned_within due_on defer_on planned_on].freeze
+
+        # rubocop:disable Metrics/BlockLength
+        arguments do
+          required(:entity).filled(included_in?: %w[tasks projects folders]).description(
+            "Type of entity to query. Choose 'tasks' for individual tasks, 'projects' for projects, " \
+            "or 'folders' for folder organization"
+          )
+
+          optional(:filters).hash do
+            optional(:projectId)
+              .filled(:string)
+              .description("Filter tasks by exact project ID (use when you know the specific project ID)")
+            optional(:projectName).filled(:string).description(
+              "Filter tasks by project name. CASE-INSENSITIVE PARTIAL MATCHING - 'review' matches " \
+              "'Weekly Review', 'Review Documents', etc. Special value: 'inbox' returns inbox tasks"
+            )
+            optional(:taskName).filled(:string).description(
+              "Filter tasks by task name. CASE-INSENSITIVE PARTIAL MATCHING - 'email' matches " \
+              "'Send email to IT', 'Confirm email' etc. Useful for fuzzy searching specific tasks across all projects"
+            )
+            optional(:folderId).filled(:string).description(
+              "Filter by folder ID. For tasks, returns tasks whose containing project is in this folder " \
+              "(or a subfolder). For projects, returns projects in this folder (or a subfolder)"
+            )
+            optional(:tags).array(:string).description(
+              "Filter by tag names. EXACT MATCH, CASE-SENSITIVE. OR logic - items must have at least " \
+              "ONE of the specified tags. Example: ['Work'] and ['work'] are different"
+            )
+            optional(:status).array(:string).description(
+              "Filter by status (OR logic - matches any). TASKS: #{QueryStatuses.task_list_for_schema} " \
+              "(next action, ready to work, waiting, due <24h, past due, completed, dropped). " \
+              "PROJECTS: #{QueryStatuses.project_list_for_schema}"
+            )
+            optional(:flagged).filled(:bool).description(
+              "Filter by flagged status. true = only flagged items, false = only unflagged items"
+            )
+            optional(:dueWithin).maybe { int? | str? }.description(
+              "Returns items due from TODAY through N days in future. Accepts: number (days), 'today', " \
+              "'tomorrow', 'this week', 'next week', or ISO date 'YYYY-MM-DD'"
+            )
+            optional(:deferredUntil).maybe { int? | str? }.description(
+              "Returns items CURRENTLY DEFERRED that will become available within N days. Accepts: number " \
+              "(days), 'today', 'tomorrow', 'this week', 'next week', or ISO date 'YYYY-MM-DD'"
+            )
+            optional(:plannedWithin).maybe { int? | str? }.description(
+              "Returns tasks planned from TODAY through N days in future. Accepts: number (days), 'today', " \
+              "'tomorrow', 'this week', 'next week', or ISO date 'YYYY-MM-DD'"
+            )
+            optional(:hasNote).filled(:bool).description(
+              "Filter by note presence. true = items with non-empty notes (whitespace ignored), " \
+              "false = items with no notes or only whitespace"
+            )
+            optional(:inbox).filled(:bool).description(
+              "Filter tasks by inbox status. true = only inbox tasks (no project), false = only tasks in a project"
+            )
+            optional(:dueOn).maybe { int? | str? }.description(
+              "Returns items due on exactly this day. Accepts: number (0 = today, 1 = tomorrow), 'today', " \
+              "'tomorrow', 'this week', 'next week', or ISO date 'YYYY-MM-DD'"
+            )
+            optional(:deferOn).maybe { int? | str? }.description(
+              "Returns items with defer date on exactly this day. Accepts: number (0 = today, 1 = tomorrow), " \
+              "'today', 'tomorrow', 'this week', 'next week', or ISO date 'YYYY-MM-DD'"
+            )
+            optional(:plannedOn).maybe { int? | str? }.description(
+              "Returns tasks with planned date on exactly this day. Accepts: number (0 = today, 1 = tomorrow), " \
+              "'today', 'tomorrow', 'this week', 'next week', or ISO date 'YYYY-MM-DD'"
+            )
+            optional(:addedWithin).filled(:integer).description(
+              "Returns items added (created) within the last N days. Example: 7 = items added in the last week"
+            )
+            optional(:addedOn).filled(:integer).description(
+              "Returns items added (created) on exactly this day. 0 = today, 1 = tomorrow, -1 = yesterday. " \
+              "Negative values look backward"
+            )
+            optional(:isRepeating)
+              .filled(:bool)
+              .description("Filter by repeating status. true = only repeating tasks, false = only non-repeating tasks")
+            optional(:completedWithin).filled(:integer).description(
+              "Returns items completed or dropped within the last N days (uses completionDate which OmniFocus " \
+              "sets for both). Example: 7 = items completed in the last week. Combine with status: ['Dropped'] " \
+              "to find only dropped items. Note: use with includeCompleted: true"
+            )
+            optional(:completedOn).filled(:integer).description(
+              "Returns items completed or dropped on exactly this day (uses completionDate which OmniFocus sets " \
+              "for both). 0 = today, -1 = yesterday. Negative values look backward. Combine with status: " \
+              "['Dropped'] to find only dropped items. Note: use with includeCompleted: true"
+            )
+          end.description(
+            "Optional filters to narrow results. ALL filters combine with AND logic (must match all). " \
+            "Within array filters (tags, status) OR logic applies"
+          )
+
+          optional(:fields).array(:string).description(
+            "Specific fields to return (reduces response size). TASK FIELDS: id, name, note, flagged, " \
+            "taskStatus, dueDate, deferDate, plannedDate, effectiveDueDate, effectiveDeferDate, " \
+            "effectivePlannedDate, completionDate, estimatedMinutes, tagNames, tags, projectName, projectId, " \
+            "parentId, childIds, hasChildren, sequential, completedByChildren, inInbox, isRepeating, " \
+            "repetitionRule, modificationDate (or modified), creationDate (or added). PROJECT FIELDS: id, " \
+            "name, status, note, folderName, folderID, sequential, dueDate, deferDate, effectiveDueDate, " \
+            "effectiveDeferDate, completedByChildren, containsSingletonActions, taskCount, tasks, " \
+            "modificationDate, creationDate. FOLDER FIELDS: id, name, path, parentFolderID, status, " \
+            "projectCount, projects, subfolders. NOTE: Date fields use 'added' and 'modified' in OmniFocus API"
+          )
+          optional(:limit)
+            .filled(:integer)
+            .description("Maximum number of items to return. Useful for large result sets. Default: no limit")
+          optional(:sortBy).filled(:string).description(
+            "Field to sort by. OPTIONS: name (alphabetical), dueDate (earliest first, null last), " \
+            "deferDate (earliest first, null last), modificationDate (most recent first), creationDate " \
+            "(oldest first), estimatedMinutes (shortest first), taskStatus (groups by status)"
+          )
+          optional(:sortOrder).filled(included_in?: %w[asc desc]).description(
+            "Sort order. 'asc' = ascending (A-Z, old-new, small-large), 'desc' = descending (Z-A, new-old, " \
+            "large-small). Default: 'asc'"
+          )
+          optional(:includeCompleted).filled(:bool).description(
+            "Include completed and dropped items. Default: false (active items only)"
+          )
+          optional(:format).filled(included_in?: %w[text json]).description(
+            "Output format. 'text' returns the default human-readable report; 'json' returns structured JSON."
+          )
+          optional(:summary)
+            .filled(:bool)
+            .description("Return only count of matches, not full details. Efficient for statistics. Default: false")
+        end
+        # rubocop:enable Metrics/BlockLength
+
+        extend OperationFactory
+
+        default_operation_factory { Operations::QueryOmnifocus.method(:call) }
+
+        def call(**args)
+          McpEnvelope.safely("executing query") do
+            params = resolve_date_filters(Params::QueryOmnifocusParams.from_mcp(args))
+
+            operation.call(params).fold(
+              on_ok: lambda { |match|
+                McpEnvelope::ToolReply.success(Presenters::QueryReply.format(args:, params:, match:))
+              },
+              on_error: ->(err) { McpEnvelope::ToolReply.failure(Presenters::QueryReply.failure(err)) }
+            )
+          end
+        end
+
+        private
+
+        # Resolve named/ISO date filters before querying. Expects a
+        # {Params::QueryOmnifocusParams} whose +filters+ hash is already
+        # snake_case.
+        def resolve_date_filters(params)
+          return params unless params.filters
+
+          f = params.filters.dup
+          DATE_FILTER_FIELDS.each do |field|
+            next if f[field].nil?
+
+            f[field] = Utils::DateFilter.to_days(Utils::DateFilter.parse(f[field]))
+          end
+          Params::QueryOmnifocusParams.new(**params.to_h, filters: f)
+        end
+      end
+    end
+  end
+end