flycal-cli 0.7.4 → 1.0

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

@@ -5,7 +5,8 @@ require "googleauth"
 require "googleauth/stores/file_token_store"
 require "fileutils"
 
-module FlycalCli
+module Flycal
+module Cli
   class Auth
     SCOPE = "https://www.googleapis.com/auth/calendar.readonly"
     REDIRECT_PORT = 9292
@@ -42,7 +43,7 @@ module FlycalCli
 
       def login
         unless Config.credentials_exist?
-          raise FlycalCli::Error,
+          raise Flycal::Error,
                 "Credentials file not found. Create #{Config.credentials_path} with OAuth credentials from Google Cloud Console.\n" \
                 "Go to: https://console.cloud.google.com/apis/credentials\n" \
                 "Create 'Desktop app' credentials and download the JSON as credentials.json"
@@ -65,7 +66,7 @@ module FlycalCli
 
         # Start local server to receive the auth code
         code = start_redirect_server(authorizer)
-        raise FlycalCli::Error, "Authentication cancelled or failed" if code.nil? || code.empty?
+        raise Flycal::Error, "Authentication cancelled or failed" if code.nil? || code.empty?
 
         authorizer.get_and_store_credentials_from_code(
           user_id: "flycal_user",
@@ -130,3 +131,4 @@ module FlycalCli
     end
   end
 end
+end

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

@@ -1,6 +1,7 @@
 # frozen_string_literal: true
 
-module FlycalCli
+module Flycal
+module Cli
   # Cross-platform clipboard helper.
   # Prefers: pbcopy (macOS) → wl-copy (Wayland) → xclip (X11) → clip (Windows).
   module Clipboard
@@ -52,3 +53,4 @@ module FlycalCli
     end
   end
 end
+end

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

@@ -3,13 +3,14 @@
 require "yaml"
 require "fileutils"
 
-module FlycalCli
+module Flycal
+module Cli
   class Config
     CONFIG_DIR = File.expand_path("~/.flycal")
     CONFIG_FILE = File.join(CONFIG_DIR, "config.yml")
     CREDENTIALS_FILE = File.join(CONFIG_DIR, "credentials.json")
     TOKENS_FILE = File.join(CONFIG_DIR, "tokens.yml")
-    DEFAULTS_FILE = File.expand_path("../../config/defaults.yml", __dir__)
+    DEFAULTS_FILE = File.expand_path("../../../config/defaults.yml", __dir__)
 
     class << self
       def load
@@ -195,3 +196,4 @@ module FlycalCli
     end
   end
 end
+end

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/description_query.rb

@@ -0,0 +1,32 @@
+# frozen_string_literal: true
+
+module Flycal
+  # Shared helpers for --description filtering and --groupBy string patterns.
+  #
+  # OR / group terms are separated by "|" (also ",").
+  # Matching is case-insensitive against event summary and description.
+  module DescriptionQuery
+    module_function
+
+    def patterns(query)
+      query.to_s.split(/[|,]/).map(&:strip).reject(&:empty?)
+    end
+
+    def match?(event_summary, event_description, query)
+      terms = patterns(query)
+      return true if terms.empty?
+
+      summary = event_summary.to_s.downcase
+      description = event_description.to_s.downcase
+      terms.any? { |term| summary.include?(term.downcase) || description.include?(term.downcase) }
+    end
+
+    def match_term?(event_summary, event_description, term)
+      needle = term.to_s.downcase
+      return false if needle.empty?
+
+      event_summary.to_s.downcase.include?(needle) ||
+        event_description.to_s.downcase.include?(needle)
+    end
+  end
+end

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/mock/calendar_service.rb

@@ -0,0 +1,43 @@
+# frozen_string_literal: true
+
+module Flycal
+  module Mock
+    # Duck-typed CalendarService backed by generated mock events (no Google API).
+    class CalendarService
+      Calendar = Struct.new(:id, :summary, :primary, keyword_init: true)
+
+      def initialize(config)
+        @config = config
+        @calendar_id = config.calendar_name
+        @events = EventGenerator.new(config).generate
+      end
+
+      def list_calendars
+        [Calendar.new(id: @calendar_id, summary: @calendar_id, primary: true)]
+      end
+
+      def list_all_events(calendar_ids, time_min:, time_max:, query: nil)
+        ids = Array(calendar_ids)
+        return [] unless ids.empty? || ids.include?(@calendar_id)
+
+        items = @events.filter_map do |event|
+          start_at = event.start.date_time
+          end_at = event.end.date_time
+          next if start_at.nil? || end_at.nil?
+          next if end_at <= time_min || start_at >= time_max
+
+          { calendar_id: @calendar_id, event: event }
+        end
+
+        if query && !query.to_s.strip.empty?
+          items.select! do |item|
+            event = item[:event]
+            DescriptionQuery.match?(event.summary, event.description, query)
+          end
+        end
+
+        items
+      end
+    end
+  end
+end