flycal-cli 0.7.4 → 1.0

data/lib/{flycal_cli/cli.rb → flycal/cli/app.rb}

@@ -9,10 +9,13 @@ require "active_support/core_ext/time"
 require "tty-prompt"
 require "tty-spinner"
 
-module FlycalCli
-  class Cli < Thor
+module Flycal
+module Cli
+  class App < Thor
     package_name "flycal"
     class_option :locale, type: :string, desc: "Override locale for this command (e.g. en, it)"
+    class_option :format, type: :string, default: "text",
+                 desc: "Output format: text or json"
 
     def self.exit_on_failure?
       true
@@ -42,7 +45,7 @@ module FlycalCli
         Auth.login
         puts "\n✓ Authentication completed successfully!"
         puts "\nRun 'flycal config' to set the default calendar."
-      rescue FlycalCli::Error => e
+      rescue Flycal::Error => e
         puts "Error: #{e.message}"
         exit 1
       end
@@ -119,20 +122,62 @@ module FlycalCli
                           Format: 30days, 48hours, 2months, 1year (no space).
                           With space use quotes: --in "30 days"
 
+      Mock mode (no Google API; triggered by --mockCalendar or --mockTemplate):
+        --mockTemplate NAME   Load defaults from mocks/ or mockTemplates/NAME.json
+        --mockCalendar NAME   Mock calendar id/name (required here or in template)
+        --mockSeed N          Reproducible random distribution
+        --mockEventCount N
+        --mockEventFrom/--mockEventTo
+        --mockEventDescriptionPatterns a,b,c
+        --mockEventDurationMin/--mockEventDurationMax
+        --mockEventHoursFrom/--mockEventHoursTo
+
       Examples:
         flycal search
         flycal search --in 30days -d placeholder
         flycal search -i 1months --description placeholder
         flycal search -f 2025-03-01 --in 2months
+        flycal search --mockTemplate mock1 --description work --calendar mock1
+        flycal search --groupBy "rui|solver" --format json
+        flycal search -c "Work|Personal"
+        flycal search --calendar Work --calendar Personal
     LONGDESC
-    option :calendar, type: :string, aliases: "-c", desc: "Calendar name or ID"
+    option :calendar, type: :string, aliases: "-c", repeatable: true,
+           desc: "Calendar name or ID (repeatable, or pipe-separated: Work|Personal)"
+
     option :from, type: :string, aliases: "-f", desc: "Start (default: today midnight)"
     option :to, type: :string, aliases: "-t", desc: "End (default: 23:59 of day 30)"
     option :in, type: :string, aliases: "-i", desc: "Duration: 30days, 48hours, 2months, 1year (overrides --to)"
-    option :description, type: :string, aliases: "-d", desc: "Filter by text in event"
+    option :description, type: :string, aliases: "-d",
+           desc: "Filter text in event (OR with |, e.g. rui|solver)"
+    option :groupBy, type: :string,
+           desc: "Grouping: day, week, month, or a string like rui|solver (default: auto from timeframe)"
+    option :mockTemplate, type: :string, desc: "Load mock defaults from mocks/<name>.json"
+    option :mockCalendar, type: :string, desc: "Use a generated mock calendar (skips Google API)"
+    option :mockSeed, type: :numeric, desc: "Seed for reproducible mock events"
+    option :mockEventDescriptionPatterns, type: :string, desc: "Comma-separated title patterns (e.g. work,personal)"
+    option :mockEventCount, type: :numeric, desc: "Number of mock events to generate"
+    option :mockEventFrom, type: :string, desc: "Mock events start date"
+    option :mockEventTo, type: :string, desc: "Mock events end date"
+    option :mockEventDurationMin, type: :string, desc: "Min mock event duration (e.g. 4h)"
+    option :mockEventDurationMax, type: :string, desc: "Max mock event duration (e.g. 4h)"
+    option :mockEventHoursFrom, type: :string, desc: "Daily start window for mock events (HH:MM)"
+    option :mockEventHoursTo, type: :string, desc: "Daily end window for mock events (HH:MM)"
+    option :nocache, type: :boolean, default: false,
+           desc: "Bypass cache and refresh from Google"
     def search
       apply_locale_override
-      unless Auth.logged_in?
+
+      mock_mode = Mock::Config.enabled?(options)
+      mock_config = nil
+      if mock_mode
+        begin
+          mock_config = Mock::Config.from_options(options)
+        rescue Flycal::Error => e
+          puts "Error: #{e.message}"
+          exit 1
+        end
+      elsif !Auth.logged_in?
         puts "You are not connected. Run 'flycal login' first."
         exit 1
       end
@@ -144,7 +189,7 @@ module FlycalCli
                    else
                      DurationParser.add_to_time(options[:in], time_min)
                    end
-      rescue FlycalCli::Error => e
+      rescue Flycal::Error => e
         puts "Error: #{e.message}"
         exit 1
       end
@@ -154,24 +199,89 @@ module FlycalCli
         exit 1
       end
 
-      creds = Auth.credentials
-      service = CalendarService.new(creds)
+      service =
+        if mock_config
+          Mock::CalendarService.new(mock_config)
+        else
+          flycal_client.calendar
+        end
 
-      calendar_ids = resolve_calendar_ids(service, options[:calendar])
+      calendar_ids =
+        if mock_config && options[:calendar].to_s.empty?
+          [mock_config.calendar_name]
+        else
+          resolve_calendar_ids(service, options[:calendar])
+        end
       if calendar_ids.empty?
         puts "No calendars found."
         exit 1
       end
 
-      events = service.list_all_events(
-        calendar_ids,
+      params = Pipeline::Params.new(
+        command: "search",
         time_min: time_min,
         time_max: time_max,
-        query: options[:description]
+        calendar_ids: calendar_ids,
+        description: options[:description],
+        calendar: options[:calendar],
+        from_option: options[:from],
+        to_option: options[:to],
+        in_option: options[:in],
+        group_by_option: options[:groupBy],
+        format: options[:format] || "text",
+        locale: Locale.current_locale,
+        use_mock: !mock_config.nil?,
+        mock_seed: mock_config&.seed,
+        mock_calendar: mock_config&.calendar_name,
+        mock_template: mock_config&.template_name
       )
 
-      print_events(service, events)
-      print_search_summary(events, time_min: time_min, time_max: time_max)
+      fingerprint = {
+        command: "search",
+        time_min: time_min,
+        time_max: time_max,
+        calendar_ids: calendar_ids,
+        description: options[:description],
+        calendar: options[:calendar],
+        from_option: options[:from],
+        to_option: options[:to],
+        in_option: options[:in],
+        group_by_option: options[:groupBy],
+        format: options[:format] || "text",
+        locale: Locale.current_locale,
+        use_mock: !mock_config.nil?,
+        mock_seed: mock_config&.seed,
+        mock_calendar: mock_config&.calendar_name,
+        mock_template: mock_config&.template_name
+      }
+      cache_key = Flycal::CacheKey.generate("search", fingerprint)
+      ttl = Flycal::CacheKey::DEFAULT_TTL_MINUTES
+      nocache = options[:nocache]
+
+      begin
+        output = nil
+        status = nil
+
+        unless nocache
+          cached = FileCache.read(cache_key, ttl_minutes: ttl)
+          if cached
+            output = cached
+            status = "HIT"
+          end
+        end
+
+        if output.nil?
+          FileCache.delete(cache_key) if nocache
+          output = Pipeline::SearchPipeline.new(service).run(params)
+          FileCache.write(cache_key, strip_cache_marker_from_output(output, params[:format]))
+          status = "MISS"
+        end
+
+        print annotate_cli_output(output, status, cache_key, params[:format])
+      rescue Flycal::Error => e
+        puts "Error: #{e.message}"
+        exit 1
+      end
     end
 
     desc "slots", "Find available time slots in your calendar"
@@ -198,7 +308,11 @@ module FlycalCli
            desc: "Start (default: now). Dates, or relative: monday, next monday, tomorrow, lunedi..."
     option :template, type: :string, aliases: "-T",
            desc: "Slot template name from config (default: first template, usually work)"
-    option :calendar, type: :string, aliases: "-c", desc: "Calendar name or ID"
+    option :calendar, type: :string, aliases: "-c", repeatable: true,
+           desc: "Calendar name or ID (repeatable, or pipe-separated: Work|Personal)"
+    option :nocache, type: :boolean, default: false,
+           desc: "Bypass cache and refresh from Google"
+
     def slots
       apply_locale_override
       unless Auth.logged_in?
@@ -228,7 +342,7 @@ module FlycalCli
         time_max = DurationParser.add_to_time(in_value, time_min)
         hours = parse_workhours(template["hours"])
         days = parse_template_days(template["days"])
-      rescue FlycalCli::Error => e
+      rescue Flycal::Error => e
         puts "Error: #{e.message}"
         exit 1
       end
@@ -238,8 +352,8 @@ module FlycalCli
         exit 1
       end
 
-      creds = Auth.credentials
-      service = CalendarService.new(creds)
+      client = flycal_client
+      service = client.calendar
 
       exclude_calendar_ids = resolve_slots_exclude_calendar_ids(service, slot_cfg, options[:calendar])
       if exclude_calendar_ids.empty?
@@ -247,53 +361,118 @@ module FlycalCli
         exit 1
       end
 
-      calendars = service.list_calendars
-      calendar_meta = exclude_calendar_ids.filter_map do |id|
-        cal = calendars.find { |c| c.id == id }
-        name = cal&.summary || id
-        { id: id, name: name }
-      end
-
-      fetch_from = time_min - free_before
-      events = exclude_calendar_ids.flat_map do |calendar_id|
-        service.list_events(
-          calendar_id,
-          time_min: fetch_from,
-          time_max: time_max
-        )
-      rescue Google::Apis::Errors::Error => e
-        warn Locale.t("errors.calendar_fetch", calendar: calendar_id, message: e.message)
-        []
+      format = (options[:format] || "text").to_s.strip.downcase
+      format = "text" if format.empty?
+
+      unless %w[json text].include?(format)
+        puts "Error: Unsupported format #{format.inspect}. Available: text, json"
+        exit 1
       end
 
-      finder = SlotFinder.new(
-        events: events,
-        time_min: time_min,
-        time_max: time_max,
-        slot_duration_seconds: slot_duration,
+      fingerprint = {
+        command: "slots",
+        calendar_ids: exclude_calendar_ids,
+        duration: duration_value,
+        from: from_value,
+        in: in_value,
+        free_before: slot_cfg["free_before"] || "0m",
+        free_after: slot_cfg["free_after"] || "0m",
+        template: template_name,
+        locale: Locale.current_locale,
+        calendar: options[:calendar],
         hours: hours,
         days: days,
-        free_before_seconds: free_before,
-        free_after_seconds: free_after
-      )
+        time_min: time_min,
+        time_max: time_max,
+        format: format
+      }
+      cache_key = Flycal::CacheKey.generate("slots", fingerprint)
+      ttl = Flycal::CacheKey::DEFAULT_TTL_MINUTES
+      nocache = options[:nocache]
+
+      output = nil
+      status = nil
+      unless nocache
+        cached = FileCache.read(cache_key, ttl_minutes: ttl)
+        if cached
+          output = cached
+          status = "HIT"
+        end
+      end
 
-      slots_by_day = finder.slots_by_day
-      slot_count = slots_by_day.values.sum(&:size)
-      puts SlotFormatter.format_header(
-        from: time_min,
-        to: time_max,
-        duration: duration_value,
-        calendars: calendar_meta,
-        count: slot_count,
-        template: template_name
-      )
-      puts ""
-      output = SlotFormatter.format_output(slots_by_day)
-      if output.empty?
-        puts Locale.t("slots.no_available")
-      else
-        puts output
-        copy_slots_to_clipboard(output)
+      if output.nil?
+        FileCache.delete(cache_key) if nocache
+
+        calendars = client.list_calendars
+        calendar_meta = exclude_calendar_ids.filter_map do |id|
+          cal = calendars.find { |c| c.id == id }
+          name = cal&.summary || id
+          { id: id, name: name }
+        end
+
+        fetch_from = time_min - free_before
+        events = exclude_calendar_ids.flat_map do |calendar_id|
+          client.list_events(
+            calendar_id,
+            time_min: fetch_from,
+            time_max: time_max
+          )
+        rescue Google::Apis::Error => e
+          warn Locale.t("errors.calendar_fetch", calendar: calendar_id, message: e.message)
+          []
+        end
+
+        finder = SlotFinder.new(
+          events: events,
+          time_min: time_min,
+          time_max: time_max,
+          slot_duration_seconds: slot_duration,
+          hours: hours,
+          days: days,
+          free_before_seconds: free_before,
+          free_after_seconds: free_after
+        )
+
+        slots_by_day = finder.slots_by_day
+
+        output =
+          if format == "json"
+            SlotFormatter.format_json(
+              slots_by_day: slots_by_day,
+              time_min: time_min,
+              time_max: time_max,
+              duration: duration_value,
+              template: template_name,
+              calendars: calendar_meta,
+              locale: Locale.current_locale,
+              calendar_option: options[:calendar],
+              from_option: options[:from],
+              in_option: options[:in],
+              free_before: slot_cfg["free_before"],
+              free_after: slot_cfg["free_after"],
+              empty_message: Locale.t("slots.no_available")
+            )
+          else
+            SlotFormatter.format_text(
+              slots_by_day: slots_by_day,
+              time_min: time_min,
+              time_max: time_max,
+              duration: duration_value,
+              calendars: calendar_meta,
+              template: template_name,
+              empty_message: Locale.t("slots.no_available")
+            )
+          end
+
+        FileCache.write(cache_key, strip_cache_marker_from_output(output, format))
+        status = "MISS"
+      end
+
+      print annotate_cli_output(output, status, cache_key, format)
+
+      if format == "text"
+        body = extract_slots_body_for_clipboard(output)
+        copy_slots_to_clipboard(body) unless body.empty?
       end
     end
 
@@ -311,15 +490,13 @@ module FlycalCli
     desc "version", "Show current flycal-cli version"
     def version
       apply_locale_override
-      puts "flycal #{FlycalCli::VERSION}"
+      puts "flycal #{Flycal::VERSION}"
     end
 
     default_task :help
 
     private
 
-    HOURS_PER_WORKING_DAY = 8
-
     def bold(str)
       "\e[1m#{str}\e[0m"
     end
@@ -332,6 +509,38 @@ module FlycalCli
       Locale.override!(options[:locale])
     end
 
+    def annotate_cli_output(output, status, cache_key, format)
+      fmt = format.to_s.strip.downcase
+      if fmt == "json"
+        payload = JSON.parse(output)
+        Flycal::CacheAnnotator.annotate_payload!(payload, status, cache_key)
+        JSON.pretty_generate(payload) + "\n"
+      else
+        Flycal::CacheAnnotator.annotate_text(output, status, cache_key)
+      end
+    end
+
+    def strip_cache_marker_from_output(output, format)
+      fmt = format.to_s.strip.downcase
+      if fmt == "json"
+        payload = JSON.parse(output)
+        JSON.pretty_generate(Flycal::CacheAnnotator.strip_for_storage(payload)) + "\n"
+      else
+        lines = output.to_s.sub(/\n\z/, "").split("\n")
+        lines.reject! { |l| l.start_with?("Cache:") }
+        "#{lines.join("\n")}\n"
+      end
+    end
+
+    def extract_slots_body_for_clipboard(text)
+      lines = text.to_s.split("\n")
+      lines.reject! { |l| l.start_with?("Cache:") }
+      blank_idx = lines.index { |l| l == "" }
+      return "" unless blank_idx
+
+      lines[(blank_idx + 1)..].join("\n").strip
+    end
+
     def with_config_interrupt_handling
       yield
     rescue Interrupt
@@ -340,12 +549,11 @@ module FlycalCli
     end
 
     def load_calendars
-      creds = Auth.credentials
-      service = CalendarService.new(creds)
+      client = flycal_client
 
       spinner = TTY::Spinner.new("#{Locale.t('common.loading_calendars')} ", format: :dots)
       spinner.auto_spin
-      calendars = service.list_calendars
+      calendars = client.list_calendars
       spinner.stop("✓")
 
       if calendars.empty?
@@ -356,6 +564,13 @@ module FlycalCli
       calendars
     end
 
+    def flycal_client
+      creds = Auth.credentials
+      raise Flycal::Error, Locale.t("errors.not_connected") if creds.nil?
+
+      Flycal.connect(credentials: creds)
+    end
+
     def calendar_choices(calendars, highlight_ids: [])
       highlights = Array(highlight_ids).compact
       calendars.to_h do |cal|
@@ -429,24 +644,11 @@ module FlycalCli
     end
 
     def resolve_calendar_refs(calendars, refs)
-      Array(refs).filter_map do |ref|
-        resolve_calendar_ref(calendars, ref)
-      end.uniq
+      Flycal::CalendarQuery.resolve_ids(calendars, refs)
     end
 
     def resolve_calendar_ref(calendars, ref)
-      ref = ref.to_s.strip
-      return nil if ref.empty?
-
-      exact = calendars.find { |cal| cal.id == ref }
-      return exact.id if exact
-
-      matches = calendars.select do |cal|
-        cal.id == ref ||
-          (cal.summary && cal.summary.downcase.include?(ref.downcase))
-      end
-
-      matches.first&.id
+      Flycal::CalendarQuery.resolve_ref(calendars, ref)
     end
 
     def resolve_slots_exclude_calendar_ids(service, slot_cfg, calendar_override)
@@ -454,21 +656,27 @@ module FlycalCli
       calendars = service.list_calendars
 
       refs = if configured.nil? || (configured.is_a?(Array) && configured.empty?)
-               fallback = calendar_override || Config.calendar_default
-               fallback ? [fallback] : []
+               override_refs = Flycal::CalendarQuery.refs(calendar_override)
+               if override_refs.any?
+                 override_refs
+               else
+                 fallback = Config.calendar_default
+                 fallback ? [ fallback ] : []
+               end
              else
                configured
              end
 
-      ids = resolve_calendar_refs(calendars, refs)
+      ids = Flycal::CalendarQuery.resolve_ids(calendars, refs)
       return ids unless ids.empty?
 
-      fallback = calendar_override || Config.calendar_default
-      if fallback
-        resolve_calendar_refs(calendars, [fallback])
+      fallback_refs = Flycal::CalendarQuery.refs(calendar_override)
+      fallback_refs = [ Config.calendar_default ].compact if fallback_refs.empty?
+      if fallback_refs.any?
+        Flycal::CalendarQuery.resolve_ids(calendars, fallback_refs)
       else
         primary = calendars.find(&:primary)
-        primary ? [primary.id] : calendars.first(1).map(&:id)
+        primary ? [ primary.id ] : calendars.first(1).map(&:id)
       end
     end
 
@@ -480,7 +688,7 @@ module FlycalCli
 
     def resolve_slots_template(slot_cfg, requested_name)
       templates = slot_cfg["templates"]
-      raise FlycalCli::Error, "slots.templates is missing in config.yml." unless templates.is_a?(Hash) && !templates.empty?
+      raise Flycal::Error, "slots.templates is missing in config.yml." unless templates.is_a?(Hash) && !templates.empty?
 
       name = requested_name.to_s.strip
       name = templates.keys.first.to_s if name.empty?
@@ -488,7 +696,7 @@ module FlycalCli
       template = templates[name]
       unless template.is_a?(Hash)
         available = templates.keys.join(", ")
-        raise FlycalCli::Error, "Unknown slots template #{name.inspect}. Available: #{available}"
+        raise Flycal::Error, "Unknown slots template #{name.inspect}. Available: #{available}"
       end
 
       [name, template]
@@ -496,10 +704,10 @@ module FlycalCli
 
     def parse_template_days(values)
       days = Array(values).map(&:to_i)
-      raise FlycalCli::Error, "slots template days cannot be empty." if days.empty?
+      raise Flycal::Error, "slots template days cannot be empty." if days.empty?
 
       invalid = days.reject { |d| d.between?(1, 7) }
-      raise FlycalCli::Error, "Invalid template days #{invalid.inspect}. Use 1 (Mon) .. 7 (Sun)." unless invalid.empty?
+      raise Flycal::Error, "Invalid template days #{invalid.inspect}. Use 1 (Mon) .. 7 (Sun)." unless invalid.empty?
 
       days.uniq
     end
@@ -514,12 +722,12 @@ module FlycalCli
 
     def parse_hour_minute(value)
       match = value.to_s.strip.match(/\A(\d{1,2}):(\d{2})\z/)
-      raise FlycalCli::Error, "Invalid time format #{value.inspect}. Use HH:MM (e.g. 9:00, 18:30)." unless match
+      raise Flycal::Error, "Invalid time format #{value.inspect}. Use HH:MM (e.g. 9:00, 18:30)." unless match
 
       hour = match[1].to_i
       minute = match[2].to_i
       unless hour.between?(0, 23) && minute.between?(0, 59)
-        raise FlycalCli::Error, "Invalid time #{value.inspect}. Hour must be 0-23 and minute 0-59."
+        raise Flycal::Error, "Invalid time #{value.inspect}. Hour must be 0-23 and minute 0-59."
       end
 
       [hour, minute]
@@ -528,18 +736,18 @@ module FlycalCli
     def parse_workhours(values)
       ranges = Array(values).map do |item|
         start_str, end_str = item.to_s.strip.split("-", 2)
-        raise FlycalCli::Error, "Invalid hours item #{item.inspect}. Use format like '9-13' or '14:30-18:00'." if start_str.nil? || end_str.nil?
+        raise Flycal::Error, "Invalid hours item #{item.inspect}. Use format like '9-13' or '14:30-18:00'." if start_str.nil? || end_str.nil?
 
         sh, sm = parse_hour_minute_flexible(start_str)
         eh, em = parse_hour_minute_flexible(end_str)
         start_minutes = (sh * 60) + sm
         end_minutes = (eh * 60) + em
-        raise FlycalCli::Error, "Invalid hours range #{item.inspect}: end must be after start." if end_minutes <= start_minutes
+        raise Flycal::Error, "Invalid hours range #{item.inspect}: end must be after start." if end_minutes <= start_minutes
 
         [sh, sm, eh, em]
       end
 
-      raise FlycalCli::Error, "template hours cannot be empty in config.yml." if ranges.empty?
+      raise Flycal::Error, "template hours cannot be empty in config.yml." if ranges.empty?
 
       ranges.sort_by { |sh, sm, _eh, _em| (sh * 60) + sm }
     end
@@ -548,7 +756,7 @@ module FlycalCli
       str = value.to_s.strip
       if str.match?(/\A\d{1,2}\z/)
         hour = str.to_i
-        raise FlycalCli::Error, "Invalid hour #{value.inspect}. Must be 0-23." unless hour.between?(0, 23)
+        raise Flycal::Error, "Invalid hour #{value.inspect}. Must be 0-23." unless hour.between?(0, 23)
 
         return [hour, 0]
       end
@@ -556,165 +764,27 @@ module FlycalCli
       parse_hour_minute(str)
     end
 
-    def resolve_calendar_ids(service, calendar_name)
+    def resolve_calendar_ids(service, calendar_option)
       calendar_lists = service.list_calendars
+      refs = Flycal::CalendarQuery.refs(calendar_option)
 
-      if calendar_name.nil? || calendar_name.empty?
+      if refs.empty?
         default_id = Config.calendar_default
-        if default_id
-          return [default_id]
-        end
-        # Use primary calendar if available
-        primary = calendar_lists.find(&:primary)
-        return [primary.id] if primary
-        # Otherwise first calendar
-        return [calendar_lists.first.id] if calendar_lists.any?
-        return []
-      end
-
-      # Search by name or ID
-      matches = calendar_lists.select do |cal|
-        cal.id == calendar_name ||
-          (cal.summary && cal.summary.downcase.include?(calendar_name.downcase))
-      end
-
-      matches.map(&:id)
-    end
-
-    def print_events(service, events)
-      # Use calendar list for names (avoids extra API calls)
-      calendar_list = service.list_calendars
-      calendar_names = calendar_list.to_h { |c| [c.id, c.summary || c.id] }
-
-      events.each do |item|
-        cal_id = item[:calendar_id]
-        event = item[:event]
-        cal_name = calendar_names[cal_id] || cal_id
-
-        start_time = event.start&.date_time || event.start&.date
-        end_time = event.end&.date_time || event.end&.date
-
-        start_str = format_datetime(start_time)
-        end_str = format_datetime(end_time)
-        desc = event.summary || "(no title)"
-        desc = event.description&.slice(0, 80) if event.summary.nil? && event.description
-
-        puts "#{cal_name} | #{start_str} | #{end_str} | #{desc}"
-      end
-    end
-
-    def format_datetime(dt)
-      return "-" if dt.nil?
-
-      if dt.is_a?(String)
-        dt
-      else
-        "#{Locale.day_abbr(dt)} #{dt.strftime("%Y-%m-%d %H:%M")}"
-      end
-    end
-
-    def format_date_with_day(dt)
-      return "-" if dt.nil?
-
-      t = dt.respond_to?(:to_time) ? dt.to_time : dt
-      "#{Locale.day_abbr(t)} #{t.strftime("%Y-%m-%d")}"
-    end
-
-    def print_search_summary(events, time_min:, time_max:)
-      event_ranges = extract_event_ranges(events)
-      total_minutes = event_ranges.sum { |s, e| (e - s) / 60 }
-
-      from_str = time_min.strftime("%a %Y-%m-%d %H:%M")
-      to_str = time_max.strftime("%a %Y-%m-%d %H:%M")
-
-      puts "\n---"
-      puts "From: #{from_str} | To: #{to_str}"
-      puts "Events found: #{events.size}"
-      puts "Total time occupied: #{format_duration(total_minutes)}"
-
-      frame_days = (time_max - time_min) / 86400.0
-      if frame_days > 30
-        print_monthly_breakdown(event_ranges, time_min, time_max)
-      elsif frame_days > 7
-        print_weekly_breakdown(event_ranges, time_min, time_max)
-      end
-    end
-
-    def extract_event_ranges(events)
-      events.filter_map do |item|
-        event = item[:event]
-        start_t = event.start&.date_time || event.start&.date
-        end_t = event.end&.date_time || event.end&.date
-        next if start_t.nil? || end_t.nil?
-
-        start_t = start_t.to_time if start_t.respond_to?(:to_time)
-        end_t = end_t.to_time if end_t.respond_to?(:to_time)
-        [start_t, end_t]
-      end
-    end
-
-    def format_duration(total_minutes)
-      hours = (total_minutes / 60).floor
-      mins = (total_minutes % 60).round
-      working_days = (total_minutes / 60.0 / HOURS_PER_WORKING_DAY).round(1)
-      "#{bold(hours)}h #{bold(mins)}min (#{bold(working_days)} working days)"
-    end
+        return [ default_id ] if default_id
 
-    def format_hours_and_days(hours, working_days)
-      "#{bold(hours)}h (#{bold(working_days)} working days)"
-    end
-
-    def minutes_in_period(event_ranges, period_start, period_end)
-      event_ranges.sum do |ev_start, ev_end|
-        overlap_start = [ev_start, period_start].max
-        overlap_end = [ev_end, period_end].min
-        overlap_sec = overlap_end - overlap_start
-        overlap_sec > 0 ? overlap_sec / 60.0 : 0
-      end
-    end
+        primary = calendar_lists.find(&:primary)
+        return [ primary.id ] if primary
+        return [ calendar_lists.first.id ] if calendar_lists.any?
 
-    def print_weekly_breakdown(event_ranges, time_min, time_max)
-      puts "\nBy week:"
-      week_num = 1
-      current = time_min.to_date.beginning_of_week(:monday)
-      while current.to_time < time_max
-        week_start = [current.to_time, time_min].max
-        week_end_date = current.end_of_week(:monday)
-        week_end = [week_end_date.to_time + 1.day, time_max].min
-        mins = minutes_in_period(event_ranges, week_start, week_end)
-        hours = (mins / 60).round(1)
-        working_days = (mins / 60.0 / HOURS_PER_WORKING_DAY).round(1)
-        start_str = format_date_with_day(week_start)
-        end_str = format_date_with_day(week_end_date)
-        puts "  #{bold(week_num)}. #{start_str} - #{end_str}: #{format_hours_and_days(hours, working_days)}"
-        week_num += 1
-        current = current + 7.days
+        return []
       end
-    end
-
-    def print_monthly_breakdown(event_ranges, time_min, time_max)
-      puts "\nBy month:"
-      month_num = 1
-      current = time_min.to_date.beginning_of_month
-      end_date = time_max.to_date
 
-      while current <= end_date
-        month_start = current.beginning_of_month.to_time
-        month_end = (current.end_of_month + 1.day).to_time
-        period_start = [month_start, time_min].max
-        period_end = [month_end, time_max].min
+      ids = Flycal::CalendarQuery.resolve_ids(calendar_lists, refs)
+      return ids unless ids.empty?
 
-        mins = minutes_in_period(event_ranges, period_start, period_end)
-        hours = (mins / 60).round(1)
-        working_days = (mins / 60.0 / HOURS_PER_WORKING_DAY).round(1)
-        month_name = "#{Locale.month_name(current)} #{current.year}"
-        start_str = format_date_with_day(period_start)
-        last_day = (period_end.to_date - 1.day)
-        end_str = format_date_with_day(last_day)
-        puts "  #{month_num}. #{month_name} (#{start_str} - #{end_str}): #{format_hours_and_days(hours, working_days)}"
-        month_num += 1
-        current = current.next_month.beginning_of_month
-      end
+      # Fall back to treating unresolved refs as literal calendar IDs
+      refs
     end
   end
 end
+end