flycal-cli 0.7.7 → 1.0

data/lib/flycal/cli/file_cache.rb

@@ -0,0 +1,44 @@
+# frozen_string_literal: true
+
+require "fileutils"
+
+module Flycal
+  module Cli
+    # File-backed cache under ~/.flycal/cache (stores rendered text/json strings).
+    class FileCache
+      class << self
+        def dir
+          File.join(Config.config_dir, "cache")
+        end
+
+        def path_for(cache_key)
+          File.join(dir, sanitize(cache_key))
+        end
+
+        def read(cache_key, ttl_minutes:)
+          path = path_for(cache_key)
+          return nil unless File.file?(path)
+
+          age = Time.now - File.mtime(path)
+          return nil if age > ttl_minutes.to_f * 60
+
+          File.read(path)
+        end
+
+        def write(cache_key, content)
+          FileUtils.mkdir_p(dir)
+          File.write(path_for(cache_key), content.to_s)
+        end
+
+        def delete(cache_key)
+          path = path_for(cache_key)
+          File.delete(path) if File.file?(path)
+        end
+
+        def sanitize(cache_key)
+          cache_key.to_s.gsub(/[^a-zA-Z0-9._-]/, "_")
+        end
+      end
+    end
+  end
+end

data/lib/flycal/cli/locale.rb

@@ -0,0 +1,58 @@
+# frozen_string_literal: true
+
+module Flycal
+  module Cli
+    # CLI-facing locale facade: prefers ~/.flycal config locale, delegates to Flycal::Locale.
+    module Locale
+      module_function
+
+      def t(key, vars = {})
+        ensure_default_provider!
+        Flycal::Locale.t(key, vars)
+      end
+
+      def day_name(date_or_time)
+        ensure_default_provider!
+        Flycal::Locale.day_name(date_or_time)
+      end
+
+      def day_abbr(date_or_time)
+        ensure_default_provider!
+        Flycal::Locale.day_abbr(date_or_time)
+      end
+
+      def month_name(date_or_time)
+        ensure_default_provider!
+        Flycal::Locale.month_name(date_or_time)
+      end
+
+      def format_long_date(date_or_time)
+        ensure_default_provider!
+        Flycal::Locale.format_long_date(date_or_time)
+      end
+
+      def current_locale
+        ensure_default_provider!
+        Flycal::Locale.current_locale
+      end
+
+      def override!(locale)
+        ensure_default_provider!
+        Flycal::Locale.override!(locale)
+      end
+
+      def ensure_default_provider!
+        return if Thread.current[:flycal_locale_default_provider]
+
+        Flycal::Locale.default_locale_provider = lambda {
+          begin
+            Config.locale
+          rescue StandardError
+            Flycal::Locale::FALLBACK_LOCALE
+          end
+        }
+      end
+      private_class_method :ensure_default_provider!
+    end
+  end
+end

data/lib/flycal/cli.rb

@@ -0,0 +1,14 @@
+# frozen_string_literal: true
+
+require "flycal"
+require "flycal/cli/config"
+require "flycal/cli/file_cache"
+require "flycal/cli/locale"
+require "flycal/cli/auth"
+require "flycal/cli/clipboard"
+require "flycal/cli/app"
+
+module Flycal
+  module Cli
+  end
+end

data/lib/flycal/client.rb

@@ -0,0 +1,186 @@
+# frozen_string_literal: true
+
+require "active_support/core_ext/object/blank"
+require "active_support/core_ext/hash/indifferent_access"
+
+module Flycal
+  # Entry point for Flycal core. Auth credentials are injected by the caller
+  # (FlycalApp / Flycal::Cli), never obtained inside core.
+  class Client
+    attr_reader :credentials, :calendar
+
+    def initialize(credentials:)
+      raise ArgumentError, "credentials are required" if credentials.nil?
+
+      @credentials = Credentials.wrap(credentials)
+      @calendar = CalendarService.new(@credentials)
+    end
+
+    def list_calendars
+      calendar.list_calendars
+    end
+
+    def list_events(calendar_id, time_min:, time_max:, query: nil)
+      calendar.list_events(calendar_id, time_min: time_min, time_max: time_max, query: query)
+    end
+
+    def list_all_events(calendar_ids, time_min:, time_max:, query: nil)
+      calendar.list_all_events(calendar_ids, time_min: time_min, time_max: time_max, query: query)
+    end
+
+    def create_event(calendar_id: "primary", summary:, start_time:, end_time:, all_day: false)
+      calendar.create_event(
+        calendar_id: calendar_id,
+        summary: summary,
+        start_time: start_time,
+        end_time: end_time,
+        all_day: all_day
+      )
+    end
+
+    def update_event(calendar_id: "primary", event_id:, summary:, start_time:, end_time:, all_day: false)
+      calendar.update_event(
+        calendar_id: calendar_id,
+        event_id: event_id,
+        summary: summary,
+        start_time: start_time,
+        end_time: end_time,
+        all_day: all_day
+      )
+    end
+
+    # Returns Rails/web-friendly event hashes (skips cancelled events).
+    def fetch_events(calendar_id:, time_min:, time_max:)
+      list_events(calendar_id, time_min: time_min, time_max: time_max)
+        .reject { |event| event.status == "cancelled" }
+        .filter_map { |event| EventMapper.to_h(event) }
+    end
+
+    def search(params = {})
+      bag = params.is_a?(Pipeline::Params) ? params : Pipeline::Params.new(params)
+      bag[:format] ||= "json"
+      bag[:locale] ||= Locale.current_locale
+      Pipeline::SearchPipeline.new(calendar).run(bag)
+    end
+
+    # Resolved slots inputs (defaults applied) suitable for CacheKey.generate.
+    # Does not call Google APIs.
+    def resolve_slots_query(params = {})
+      p = params.respond_to?(:with_indifferent_access) ? params.with_indifferent_access : params
+      calendar_ids = Array(p[:calendar_ids]).map(&:to_s).reject(&:empty?)
+      raise Flycal::Error, "calendar_ids are required" if calendar_ids.empty?
+
+      duration_value = p[:duration].presence || "45min"
+      in_value = p[:in].presence || "1 week"
+      from_value = p[:from].presence || "now"
+      free_before_value = p[:free_before].presence || "0m"
+      free_after_value = p[:free_after].presence || "0m"
+      template_name = p[:template].presence || "work"
+      locale = p[:locale].presence || Locale.current_locale
+
+      slot_duration = DurationParser.to_seconds(duration_value)
+      free_before = DurationParser.to_seconds(free_before_value)
+      free_after = DurationParser.to_seconds(free_after_value)
+      time_min = DateTimeParser.parse(from_value.to_s, locale: locale)
+      time_max = DurationParser.add_to_time(in_value, time_min)
+      raise Flycal::Error, "'from' must be before end of window" if time_min >= time_max
+
+      hours = normalize_hours(p[:hours]) || SlotFinder::DEFAULT_HOURS
+      days = normalize_days(p[:days]) || SlotFinder::DEFAULT_DAYS
+
+      {
+        command: "slots",
+        calendar_ids: calendar_ids,
+        duration: duration_value,
+        from: from_value,
+        in: in_value,
+        free_before: free_before_value,
+        free_after: free_after_value,
+        template: template_name,
+        locale: locale,
+        calendar: p[:calendar],
+        hours: hours,
+        days: days,
+        time_min: time_min,
+        time_max: time_max,
+        slot_duration_seconds: slot_duration,
+        free_before_seconds: free_before,
+        free_after_seconds: free_after,
+        format: p[:format].presence || "json"
+      }
+    end
+
+    # Find free slots. +params+ keys (string/symbol):
+    #   calendar_ids (required), duration (e.g. "45min"), from, in,
+    #   free_before, free_after, hours ([[9,0,18,0]]), days ([1..5]),
+    #   template (label), locale, calendar (label for meta)
+    # Returns a Hash suitable for JSON rendering.
+    def slots(params = {})
+      p = params.respond_to?(:with_indifferent_access) ? params.with_indifferent_access : params
+      q = resolve_slots_query(p)
+
+      calendars = list_calendars
+      calendar_meta = q[:calendar_ids].filter_map do |id|
+        cal = calendars.find { |c| c.id == id }
+        { id: id, name: cal&.summary || id }
+      end
+
+      fetch_from = q[:time_min] - q[:free_before_seconds]
+      events = q[:calendar_ids].flat_map do |calendar_id|
+        list_events(calendar_id, time_min: fetch_from, time_max: q[:time_max])
+      rescue StandardError => e
+        warn "Flycal slots: skip calendar #{calendar_id}: #{e.message}"
+        []
+      end
+
+      finder = SlotFinder.new(
+        events: events,
+        time_min: q[:time_min],
+        time_max: q[:time_max],
+        slot_duration_seconds: q[:slot_duration_seconds],
+        hours: q[:hours],
+        days: q[:days],
+        free_before_seconds: q[:free_before_seconds],
+        free_after_seconds: q[:free_after_seconds]
+      )
+
+      SlotFormatter.payload_hash(
+        slots_by_day: finder.slots_by_day,
+        time_min: q[:time_min],
+        time_max: q[:time_max],
+        duration: q[:duration],
+        template: q[:template],
+        calendars: calendar_meta,
+        locale: q[:locale],
+        calendar_option: q[:calendar],
+        from_option: p[:from],
+        in_option: p[:in],
+        free_before: q[:free_before],
+        free_after: q[:free_after],
+        empty_message: Locale.t("slots.no_available")
+      )
+    end
+
+    private
+
+    def normalize_hours(value)
+      return nil if value.blank?
+      return value if value.is_a?(Array) && value.first.is_a?(Array)
+
+      # "9:00-18:00" or ["9:00-18:00", "14:00-17:00"]
+      Array(value).map do |window|
+        start_s, end_s = window.to_s.split("-", 2).map(&:strip)
+        sh, sm = start_s.split(":").map(&:to_i)
+        eh, em = end_s.split(":").map(&:to_i)
+        [ sh, sm, eh, em ]
+      end
+    end
+
+    def normalize_days(value)
+      return nil if value.blank?
+      return value.map(&:to_i) if value.is_a?(Array)
+
+      value.to_s.split(",").map(&:strip).reject(&:empty?).map(&:to_i)
+    end
+  end
+end

data/lib/flycal/credentials.rb

@@ -0,0 +1,34 @@
+# frozen_string_literal: true
+
+require "googleauth"
+
+module Flycal
+  # Builds Google auth credentials from externally supplied tokens
+  # (Rails OAuth session, CLI token store, etc.).
+  class Credentials
+    DEFAULT_SCOPE = "https://www.googleapis.com/auth/calendar.readonly"
+
+    def self.from_tokens(
+      access_token:,
+      refresh_token: nil,
+      client_id:,
+      client_secret:,
+      expires_at: nil,
+      scope: DEFAULT_SCOPE
+    )
+      opts = {
+        client_id: client_id,
+        client_secret: client_secret,
+        scope: scope,
+        access_token: access_token,
+        refresh_token: refresh_token
+      }
+      opts[:expires_at] = expires_at.to_i if expires_at
+      Google::Auth::UserRefreshCredentials.new(**opts)
+    end
+
+    def self.wrap(credentials)
+      credentials
+    end
+  end
+end

data/lib/{flycal_cli → flycal}/date_time_parser.rb

@@ -5,7 +5,7 @@ require "time"
 require "active_support/core_ext/time"
 require "active_support/core_ext/date"
 
-module FlycalCli
+module Flycal
   # Parses CLI date/time arguments in a locale-aware way.
   #
   # Always accepts ISO-like forms:
@@ -39,7 +39,7 @@ module FlycalCli
     class << self
       def parse(str, end_of_day: false, locale: nil)
         value = str.to_s.strip
-        raise FlycalCli::Error, invalid_message(str) if value.empty?
+        raise Flycal::Error, invalid_message(str) if value.empty?
 
         relative = parse_relative(value, end_of_day: end_of_day)
         return relative if relative
@@ -65,7 +65,7 @@ module FlycalCli
           parsed = Time.parse(value)
           return end_of_day && !time_component?(value) ? end_of_day_for(parsed.to_date) : parsed
         rescue ArgumentError
-          raise FlycalCli::Error, invalid_message(str)
+          raise Flycal::Error, invalid_message(str)
         end
       end
 
@@ -194,7 +194,7 @@ module FlycalCli
 
         Time.local(year, month, day, hour, min || 0, sec || 0)
       rescue ArgumentError
-        raise FlycalCli::Error, "Invalid date: #{year}-#{month}-#{day}"
+        raise Flycal::Error, "Invalid date: #{year}-#{month}-#{day}"
       end
 
       def end_of_day_for(date)

data/lib/{flycal_cli → flycal}/description_query.rb

@@ -1,9 +1,9 @@
 # frozen_string_literal: true
 
-module FlycalCli
-  # Shared helpers for --description filtering and --groupBy description.
+module Flycal
+  # Shared helpers for --description filtering and --groupBy string patterns.
   #
-  # OR terms are separated by "|" (also "," for grouping convenience).
+  # OR / group terms are separated by "|" (also ",").
   # Matching is case-insensitive against event summary and description.
   module DescriptionQuery
     module_function

data/lib/{flycal_cli → flycal}/duration_parser.rb

@@ -3,7 +3,7 @@
 require "active_support/core_ext/numeric/time"
 require "active_support/core_ext/integer/time"
 
-module FlycalCli
+module Flycal
   class DurationParser
     UNITS = {
       "s" => :seconds, "sec" => :seconds, "second" => :seconds, "seconds" => :seconds,
@@ -20,12 +20,12 @@ module FlycalCli
         normalized = str.to_s.strip.downcase
         match = normalized.match(/\A(\d+(?:\.\d+)?)\s*([a-z]+)\z/) ||
                 normalized.match(/\A(\d+(?:\.\d+)?)([a-z]+)\z/)
-        raise FlycalCli::Error, invalid_message(str) unless match
+        raise Flycal::Error, invalid_message(str) unless match
 
         value = match[1].to_f
         unit_key = match[2]
         unit = UNITS[unit_key]
-        raise FlycalCli::Error, invalid_message(str) unless unit
+        raise Flycal::Error, invalid_message(str) unless unit
         # Ambiguous bare "m": treat as minutes (not months)
         unit = :minutes if unit_key == "m"
 

data/lib/flycal/error.rb

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+module Flycal
+  class Error < StandardError; end
+end

data/lib/flycal/event_mapper.rb

@@ -0,0 +1,58 @@
+# frozen_string_literal: true
+
+require "securerandom"
+
+module Flycal
+  # Normalizes Google Calendar API event objects into plain hashes.
+  module EventMapper
+    module_function
+
+    def to_h(event)
+      start_time = extract_start(event)
+      end_time = extract_end(event, start_time)
+
+      {
+        id: event.id || SecureRandom.uuid,
+        summary: event.summary || "(No title)",
+        description: event.description,
+        location: event.location,
+        start_time: start_time,
+        end_time: end_time,
+        all_day: !event.start&.date.nil? && event.start&.date_time.nil?,
+        status: event.status || "confirmed",
+        html_link: event.html_link,
+        creator: event.creator&.email,
+        organizer: event.organizer&.email,
+        attendees: Array(event.attendees).map do |attendee|
+          { email: attendee.email, response_status: attendee.response_status }
+        end
+      }
+    rescue StandardError
+      nil
+    end
+
+    def extract_start(event)
+      if event.start&.date_time
+        event.start.date_time
+      elsif event.start&.date
+        Date.parse(event.start.date.to_s)
+      else
+        Time.now
+      end
+    rescue ArgumentError
+      Time.now
+    end
+
+    def extract_end(event, start_time)
+      if event.end&.date_time
+        event.end.date_time
+      elsif event.end&.date
+        Date.parse(event.end.date.to_s)
+      else
+        start_time + 3600
+      end
+    rescue ArgumentError
+      start_time + 3600
+    end
+  end
+end

data/lib/{flycal_cli → flycal}/locale.rb

@@ -2,7 +2,9 @@
 
 require "json"
 
-module FlycalCli
+module Flycal
+  # Shared i18n helpers used by core formatters/pipelines.
+  # Locale JSON files live with the CLI package (flycal_cli/locales) by default.
   module Locale
     module_function
 
@@ -38,20 +40,50 @@ module FlycalCli
     end
 
     def current_locale
-      Thread.current[:flycal_locale_override] || Config.locale
+      Thread.current[:flycal_locale_override] || default_locale
+    end
+
+    def default_locale
+      provider = Thread.current[:flycal_locale_default_provider]
+      value = provider.call if provider.respond_to?(:call)
+      value = value.to_s.strip if value
+      value && !value.empty? ? value : FALLBACK_LOCALE
     rescue StandardError
       FALLBACK_LOCALE
     end
 
+    def default_locale_provider=(provider)
+      Thread.current[:flycal_locale_default_provider] = provider
+    end
+
     def override!(locale)
       Thread.current[:flycal_locale_override] = locale.to_s if locale && !locale.to_s.strip.empty?
     end
 
+    def locales_path
+      Thread.current[:flycal_locales_path] || default_locales_path
+    end
+
+    def locales_path=(path)
+      Thread.current[:flycal_locales_path] = path
+      @cache = nil
+    end
+
+    def default_locales_path
+      # Monorepo: flycal_cli/locales; gem package: lib/../locales
+      candidates = [
+        File.expand_path("../../flycal_cli/locales", __dir__),
+        File.expand_path("../../../locales", __dir__),
+        File.expand_path("../../locales", __dir__)
+      ]
+      candidates.find { |path| Dir.exist?(path) } || candidates.first
+    end
+
     def translations(locale)
       @cache ||= {}
       loc = locale.to_s
       @cache[loc] ||= begin
-        path = File.expand_path("../../locales/#{loc}.json", __dir__)
+        path = File.join(locales_path, "#{loc}.json")
         File.exist?(path) ? JSON.parse(File.read(path)) : {}
       end
     end

data/lib/{flycal_cli → flycal}/mock/calendar_service.rb

@@ -1,6 +1,6 @@
 # frozen_string_literal: true
 
-module FlycalCli
+module Flycal
   module Mock
     # Duck-typed CalendarService backed by generated mock events (no Google API).
     class CalendarService

data/lib/{flycal_cli → flycal}/mock/config.rb

@@ -2,7 +2,7 @@
 
 require "json"
 
-module FlycalCli
+module Flycal
   module Mock
     # Resolves mock options from CLI and/or a JSON template under mocks/.
     class Config
@@ -45,7 +45,7 @@ module FlycalCli
         calendar = merged["mockCalendar"].to_s
         calendar = options[:mockCalendar].to_s if calendar.empty?
         @calendar_name = calendar
-        raise FlycalCli::Error,
+        raise Flycal::Error,
               "Mock mode requires mockCalendar in the template (or --mockCalendar)." if @calendar_name.empty?
 
         @raw = merged
@@ -84,14 +84,14 @@ module FlycalCli
         return {} if name.to_s.empty?
 
         path = find_template_path(name)
-        raise FlycalCli::Error, "Mock template not found: #{name.inspect} (looked in ./mocks, ./mockTemplates, and gem paths)." unless path
+        raise Flycal::Error, "Mock template not found: #{name.inspect} (looked in ./mocks, ./mockTemplates, and gem paths)." unless path
 
         data = JSON.parse(File.read(path))
-        raise FlycalCli::Error, "Mock template #{name.inspect} must be a JSON object." unless data.is_a?(Hash)
+        raise Flycal::Error, "Mock template #{name.inspect} must be a JSON object." unless data.is_a?(Hash)
 
         data
       rescue JSON::ParserError => e
-        raise FlycalCli::Error, "Invalid mock template JSON (#{name}): #{e.message}"
+        raise Flycal::Error, "Invalid mock template JSON (#{name}): #{e.message}"
       end
 
       def find_template_path(name)
@@ -108,13 +108,13 @@ module FlycalCli
 
       def split_patterns(value)
         list = value.to_s.split(",").map(&:strip).reject(&:empty?)
-        raise FlycalCli::Error, "mockEventDescriptionPatterns must list at least one pattern." if list.empty?
+        raise Flycal::Error, "mockEventDescriptionPatterns must list at least one pattern." if list.empty?
 
         list
       end
 
       def parse_date(value, end_of_day:)
-        raise FlycalCli::Error, "Missing mock date." if value.to_s.empty?
+        raise Flycal::Error, "Missing mock date." if value.to_s.empty?
 
         DateTimeParser.parse(value.to_s, end_of_day: end_of_day)
       end
@@ -122,12 +122,12 @@ module FlycalCli
       def parse_hour_minute(value)
         str = value.to_s.strip
         match = str.match(/\A(\d{1,2}):(\d{2})\z/)
-        raise FlycalCli::Error, "Invalid mock hour #{value.inspect}. Use HH:MM (e.g. 09:00)." unless match
+        raise Flycal::Error, "Invalid mock hour #{value.inspect}. Use HH:MM (e.g. 09:00)." unless match
 
         hour = match[1].to_i
         min = match[2].to_i
         unless hour.between?(0, 23) && min.between?(0, 59)
-          raise FlycalCli::Error, "Invalid mock hour #{value.inspect}. Use HH:MM (e.g. 09:00)."
+          raise Flycal::Error, "Invalid mock hour #{value.inspect}. Use HH:MM (e.g. 09:00)."
         end
 
         [hour, min]
@@ -147,22 +147,22 @@ module FlycalCli
         missing << "mockEventTo" if range_to.nil?
         missing << "mockEventDurationMin" if duration_min_seconds <= 0
         missing << "mockEventDurationMax" if duration_max_seconds <= 0
-        raise FlycalCli::Error, "Missing mock parameters: #{missing.join(", ")}" unless missing.empty?
+        raise Flycal::Error, "Missing mock parameters: #{missing.join(", ")}" unless missing.empty?
 
         if duration_min_seconds > duration_max_seconds
-          raise FlycalCli::Error, "mockEventDurationMin must be <= mockEventDurationMax."
+          raise Flycal::Error, "mockEventDurationMin must be <= mockEventDurationMax."
         end
         if range_from > range_to
-          raise FlycalCli::Error, "mockEventFrom must be before mockEventTo."
+          raise Flycal::Error, "mockEventFrom must be before mockEventTo."
         end
 
         from_mins = hours_from[0] * 60 + hours_from[1]
         to_mins = hours_to[0] * 60 + hours_to[1]
         if from_mins >= to_mins
-          raise FlycalCli::Error, "mockEventHoursFrom must be before mockEventHoursTo."
+          raise Flycal::Error, "mockEventHoursFrom must be before mockEventHoursTo."
         end
         if duration_min_seconds > (to_mins - from_mins) * 60
-          raise FlycalCli::Error,
+          raise Flycal::Error,
                 "mockEventDurationMin does not fit in mockEventHoursFrom..mockEventHoursTo window."
         end
       end

data/lib/{flycal_cli → flycal}/mock/event_generator.rb

@@ -1,6 +1,6 @@
 # frozen_string_literal: true
 
-module FlycalCli
+module Flycal
   module Mock
     # Builds deterministic fake calendar events from a Mock::Config.
     class EventGenerator
@@ -60,7 +60,7 @@ module FlycalCli
         window_end = day.to_time + (to_h * 3600) + (to_m * 60)
         latest_start = window_end - duration_seconds
         if latest_start < window_start
-          raise FlycalCli::Error, "Mock event duration does not fit in the daily hours window."
+          raise Flycal::Error, "Mock event duration does not fit in the daily hours window."
         end
 
         span = (latest_start - window_start).to_i

data/lib/flycal/mock.rb

@@ -0,0 +1,6 @@
+# frozen_string_literal: true
+
+module Flycal
+  module Mock
+  end
+end