r_cal 0.1.1 → 0.2.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 4b8e1b4227647300ed2520994313f6c1646af59edb0b09832981309bd3f0c57f
-  data.tar.gz: '006687ea8d92378c0c4ccd82128c7a597b8584469c8aa2c2eadd6878432896ee'
+  metadata.gz: 3197ee3a981b8c987ffc5aaf6e2676a91e602359562e7143ed9158d712e43711
+  data.tar.gz: 26d484aa6eb13877e489215f353c6f035d208e054201643ca346aa19ba8c74fd
 SHA512:
-  metadata.gz: f142a4a0075c242752b4ff9f954e8861be232df1900084660958ed9a7c76cad1ee0d283854befae76100ab49c468621ebe14497da39c9b9b5a4a81d20dc9c077
-  data.tar.gz: 508b0c8cc9030dd8d28ef0652910fad027f79391768395e9aa745deb8e9cad05fb097edf34cca74c34cc35ecbc70dd3aa61747ae464c2a6738e10a90e032b39f
+  metadata.gz: 507cdd4df0c1ac7c015632e230a34230bc3925c824e4398b25127ba8077f30595e842318d6d5dbafe4ed2f1090c68ad4eeea7f262162d54ee25592295da3da56
+  data.tar.gz: 36b299e87193a9fae11871056449ff89d552e8cbec669ebce391cd133591473300ff0d8968b9ceae09555bcc4fca2ef87ff5b4c0ff6e67ffbe98a105f1bc5d42

data/Gemfile.lock

@@ -1,7 +1,7 @@
 PATH
   remote: .
   specs:
-    r_cal (0.1.0)
+    r_cal (0.1.1)
       chronic (~> 0.10)
       chronic_duration (~> 0.10)
       cli-kit (~> 5.2.0)
@@ -210,7 +210,7 @@ CHECKSUMS
   prism (1.9.0) sha256=7b530c6a9f92c24300014919c9dcbc055bf4cdf51ec30aed099b06cd6674ef85
   pstore (0.2.0) sha256=d6e5c7e8e22392235e88bbe82959059ba768a797b5bd0ebf5ac80a3311ce74a8
   public_suffix (7.0.2) sha256=9114090c8e4e7135c1fd0e7acfea33afaab38101884320c65aaa0ffb8e26a857
-  r_cal (0.1.0)
+  r_cal (0.1.1)
   racc (1.8.1) sha256=4a7f6929691dbec8b5209a0b373bc2614882b55fc5d2e447a21aaa691303d62f
   rainbow (3.1.1) sha256=039491aa3a89f42efa1d6dec2fc4e62ede96eb6acd95e52f1ad581182b79bc6a
   rake (13.3.1) sha256=8c9e89d09f66a26a01264e7e3480ec0607f0c497a861ef16063604b1b08eb19c

data/lib/rcal/adapters/calendar/base.rb

@@ -10,6 +10,10 @@ module Rcal
           raise NotImplementedError, "#{self.class} must implement #list_events"
         end
 
+        def get_calendar(calendar_id:)
+          raise NotImplementedError, "#{self.class} must implement #get_calendar"
+        end
+
         def get_event(calendar_id:, event_id:)
           raise NotImplementedError, "#{self.class} must implement #get_event"
         end

data/lib/rcal/adapters/calendar/google.rb

@@ -19,6 +19,11 @@ module Rcal
           items.map { |cal| build_calendar(cal) }
         end
 
+        def get_calendar(calendar_id:)
+          google_calendar = @service.get_calendar(calendar_id)
+          build_calendar(google_calendar)
+        end
+
         def list_events(calendar_id:, time_min:, time_max:)
           response = @service.list_events(
             calendar_id,
@@ -93,7 +98,8 @@ module Rcal
             recurring_event_id: google_event.recurring_event_id,
             response_status: extract_self_response_status(google_event.attendees),
             attendees: build_attendees(google_event.attendees),
-            timezone: google_event.start&.time_zone
+            timezone: google_event.start&.time_zone,
+            color_id: google_event.color_id
           )
         end
 
@@ -134,22 +140,31 @@ module Rcal
           google_event = ::Google::Apis::CalendarV3::Event.new(
             summary: event.summary,
             description: event.description,
-            location: event.location
+            location: event.location,
+            color_id: event.color_id,
+            recurrence: event.recurrence,
+            transparency: event.transparency
           )
 
+          tz = event.timezone
+
           if event.all_day?
             google_event.start = ::Google::Apis::CalendarV3::EventDateTime.new(
-              date: event.start_time.to_date.to_s
+              date: event.start_time.to_date.to_s,
+              time_zone: tz
             )
             google_event.end = ::Google::Apis::CalendarV3::EventDateTime.new(
-              date: event.end_time.to_date.to_s
+              date: event.end_time.to_date.to_s,
+              time_zone: tz
             )
           else
             google_event.start = ::Google::Apis::CalendarV3::EventDateTime.new(
-              date_time: event.start_time.iso8601
+              date_time: event.start_time.iso8601,
+              time_zone: tz
             )
             google_event.end = ::Google::Apis::CalendarV3::EventDateTime.new(
-              date_time: event.end_time.iso8601
+              date_time: event.end_time.iso8601,
+              time_zone: tz
             )
           end
 

data/lib/rcal/calendar_service.rb

@@ -13,6 +13,10 @@ module Rcal
         adapter.list_calendars
       end
 
+      def get_calendar(calendar_id:)
+        adapter.get_calendar(calendar_id: calendar_id)
+      end
+
       def list_events(calendar_id:, time_min:, time_max:)
         adapter.list_events(
           calendar_id: calendar_id,

data/lib/rcal/color_map.rb

@@ -0,0 +1,40 @@
+module Rcal
+  module ColorMap
+    COLORS = {
+      "lavender" => "1",
+      "sage" => "2",
+      "grape" => "3",
+      "flamingo" => "4",
+      "banana" => "5",
+      "tangerine" => "6",
+      "peacock" => "7",
+      "graphite" => "8",
+      "blueberry" => "9",
+      "basil" => "10",
+      "tomato" => "11"
+    }.freeze
+
+    IDS = COLORS.values.freeze
+
+    class << self
+      # Resolves a color name or numeric ID to a Google Calendar color ID string.
+      # Accepts names ("tomato"), IDs ("11"), or IDs as integers (11).
+      # Raises Rcal::Error for invalid input.
+      def resolve(input)
+        normalized = input.to_s.strip.downcase
+
+        # Try as a name first
+        return COLORS[normalized] if COLORS.key?(normalized)
+
+        # Try as a numeric ID
+        return normalized if IDS.include?(normalized)
+
+        raise Rcal::Error, "Unknown color: #{input}. Run 'rcal colors' to see available colors."
+      end
+
+      def all
+        COLORS
+      end
+    end
+  end
+end

data/lib/rcal/commands/add.rb

@@ -5,6 +5,9 @@ require_relative "../date_parser"
 require_relative "../duration_parser"
 require_relative "../models/event"
 require_relative "../presenters/event_presenter"
+require_relative "../color_map"
+require_relative "../timezone_resolver"
+require_relative "../recurrence_builder"
 
 module Rcal
   module Commands
@@ -26,12 +29,26 @@ module Rcal
             --location=TEXT     Event location
             --description=TEXT  Event description
             --calendar=ID       Calendar to add event to (default: primary)
+            --color=COLOR       Event color (name or ID). Run 'rcal colors' to see options
+            --timezone=TZ       IANA timezone (e.g., "America/New_York"). Default: calendar's timezone
             --all-day           Create an all-day event
+            --free              Mark event as free (default: busy)
+
+          Recurrence:
+            --repeat=FREQ       Recurrence frequency: daily, weekly, monthly, yearly
+            --days=DAYS         Days of week (e.g., "MO,WE,FR" or "Monday,Wed"). Requires --repeat
+            --count=N           Number of occurrences. Cannot be used with --until
+            --until=DATE        End date for recurrence. Cannot be used with --count
+            --interval=N        Repeat every N periods (e.g., --repeat=weekly --interval=2 = biweekly)
 
           Examples:
             rcal add --title="Team Meeting" --when="tomorrow 3pm"
             rcal add --title="Lunch" --when="friday noon" --duration=1h --location="Cafe"
             rcal add --title="Vacation" --when="monday" --all-day
+            rcal add --title="Important" --when="tomorrow 9am" --color=tomato
+            rcal add --title="Focus Time" --when="tomorrow 2pm" --duration=2h --free
+            rcal add --title="Standup" --when="monday 9am" --repeat=weekly --days=MO,WE,FR
+            rcal add --title="1:1" --when="monday 2pm" --repeat=weekly --interval=2 --count=10
         HELP
       end
 
@@ -53,8 +70,8 @@ module Rcal
 
       private
 
-      VALUE_OPTIONS = %w[title when duration location description calendar].freeze
-      FLAG_OPTIONS = {"all-day" => :all_day}.freeze
+      VALUE_OPTIONS = %w[title when duration location description calendar color timezone repeat days count until interval].freeze
+      FLAG_OPTIONS = {"all-day" => :all_day, "free" => :free}.freeze
 
       def parse_options(args)
         options = {calendar: "primary", all_day: false}
@@ -91,12 +108,27 @@ module Rcal
           raise CLI::Kit::Abort, "When is required.\n" \
             "Usage: rcal add --title=\"Meeting\" --when=\"tomorrow 3pm\""
         end
+
+        validate_recurrence_options!(options)
+      end
+
+      def validate_recurrence_options!(options)
+        recurrence_modifiers = %i[days count until interval]
+        has_modifiers = recurrence_modifiers.any? { |key| options[key] }
+
+        if has_modifiers && options[:repeat].nil?
+          raise CLI::Kit::Abort,
+            "Recurrence modifiers (--days, --count, --until, --interval) require --repeat.\n" \
+            "Usage: rcal add --title=\"Meeting\" --when=\"monday 9am\" --repeat=weekly --days=MO,WE,FR"
+        end
       end
 
       def build_event(options)
         start_time = parse_start_time(options[:when])
         duration = parse_duration(options[:duration])
         end_time = calculate_end_time(start_time, duration, options[:all_day])
+        timezone = resolve_timezone(options[:timezone], options[:calendar])
+        recurrence = build_recurrence(options)
 
         Event.new(
           summary: options[:title],
@@ -104,7 +136,11 @@ module Rcal
           end_time: end_time,
           location: options[:location],
           description: options[:description],
-          all_day: options[:all_day]
+          all_day: options[:all_day],
+          color_id: resolve_color(options[:color]),
+          timezone: timezone,
+          recurrence: recurrence,
+          transparency: options[:free] ? "transparent" : nil
         )
       end
 
@@ -131,6 +167,32 @@ module Rcal
         end
       end
 
+      def build_recurrence(options)
+        return nil unless options[:repeat]
+
+        RecurrenceBuilder.build(
+          freq: options[:repeat],
+          days: options[:days],
+          count: options[:count],
+          until_date: options[:until],
+          interval: options[:interval]
+        )
+      rescue Rcal::Error => e
+        raise CLI::Kit::Abort, e.message
+      end
+
+      def resolve_timezone(timezone_input, calendar_id)
+        TimezoneResolver.resolve(explicit: timezone_input, calendar_id: calendar_id)
+      end
+
+      def resolve_color(color_input)
+        return nil if color_input.nil?
+
+        ColorMap.resolve(color_input)
+      rescue Rcal::Error => e
+        raise CLI::Kit::Abort, e.message
+      end
+
       def display_created_event(event)
         presenter = Presenters::EventPresenter.new(event)
         puts CLI::UI.fmt("{{v}} Event created: #{presenter.to_s_with_date}")

data/lib/rcal/commands/colors.rb

@@ -0,0 +1,34 @@
+require "rcal"
+require_relative "../color_map"
+
+module Rcal
+  module Commands
+    class Colors < Rcal::Command
+      def self.help
+        <<~HELP
+          List available event colors.
+
+          Usage: rcal colors
+
+          Shows the color names and IDs that can be used with the --color option
+          on the 'add' and 'edit' commands.
+
+          Examples:
+            rcal colors
+            rcal add --title="Meeting" --when="tomorrow 3pm" --color=tomato
+            rcal edit abc123 --color=peacock
+        HELP
+      end
+
+      def run(_args, _name)
+        puts "Available event colors:\n\n"
+
+        ColorMap.all.each do |name, id|
+          puts "  #{id.rjust(2)}  #{name}"
+        end
+
+        puts "\nUsage: rcal add --color=NAME or rcal add --color=ID"
+      end
+    end
+  end
+end

data/lib/rcal/commands/edit.rb

@@ -5,6 +5,9 @@ require_relative "../date_parser"
 require_relative "../duration_parser"
 require_relative "../models/event"
 require_relative "../presenters/event_presenter"
+require_relative "../color_map"
+require_relative "../timezone_resolver"
+require_relative "../recurrence_builder"
 
 module Rcal
   module Commands
@@ -25,11 +28,27 @@ module Rcal
             --location=TEXT     New event location
             --description=TEXT  New event description
             --calendar=ID       Calendar containing the event (default: primary)
+            --color=COLOR       New event color (name or ID). Run 'rcal colors' to see options
+            --timezone=TZ       IANA timezone (e.g., "America/New_York")
+            --free              Mark event as free (does not block calendar)
+            --busy              Mark event as busy (blocks calendar)
+
+          Recurrence:
+            --repeat=FREQ       Change recurrence: daily, weekly, monthly, yearly, or "none" to remove
+            --days=DAYS         Days of week (e.g., "MO,WE,FR" or "Monday,Wed"). Requires --repeat
+            --count=N           Number of occurrences. Cannot be used with --until
+            --until=DATE        End date for recurrence. Cannot be used with --count
+            --interval=N        Repeat every N periods (e.g., --repeat=weekly --interval=2 = biweekly)
 
           Examples:
             rcal edit abc123 --title="Updated Meeting"
             rcal edit abc123 --when="tomorrow 4pm" --duration=30m
             rcal edit abc123 --location="Room 202" --calendar=work@company.com
+            rcal edit abc123 --color=peacock
+            rcal edit abc123 --free
+            rcal edit abc123 --busy
+            rcal edit abc123 --repeat=weekly --days=MO,WE,FR
+            rcal edit abc123 --repeat=none
         HELP
       end
 
@@ -55,7 +74,8 @@ module Rcal
 
       private
 
-      VALUE_OPTIONS = %w[title when duration location description calendar].freeze
+      VALUE_OPTIONS = %w[title when duration location description calendar color timezone repeat days count until interval].freeze
+      FLAG_OPTIONS = {"free" => :free, "busy" => :busy}.freeze
 
       def parse_options(args)
         options = {calendar: "primary"}
@@ -64,11 +84,15 @@ module Rcal
           case parse_arg(arg)
           in {option:, value:} if VALUE_OPTIONS.include?(option)
             options[option.tr("-", "_").to_sym] = value
+          in {flag:} if FLAG_OPTIONS.key?(flag)
+            options[FLAG_OPTIONS[flag]] = true
           else
             nil
           end
         end
 
+        validate_transparency_options!(options)
+
         options
       end
 
@@ -91,6 +115,22 @@ module Rcal
         end
       end
 
+      def validate_transparency_options!(options)
+        if options[:free] && options[:busy]
+          raise CLI::Kit::Abort, "Cannot use --free and --busy together."
+        end
+      end
+
+      def resolve_transparency(options, existing_event)
+        if options[:free]
+          "transparent"
+        elsif options[:busy]
+          "opaque"
+        else
+          existing_event.transparency
+        end
+      end
+
       def fetch_event(calendar_id, event_id)
         CalendarService.get_event(calendar_id: calendar_id, event_id: event_id)
       rescue => e
@@ -101,6 +141,10 @@ module Rcal
         summary = options[:title] || existing_event.summary
         location = options.key?(:location) ? options[:location] : existing_event.location
         description = options.key?(:description) ? options[:description] : existing_event.description
+        color_id = options.key?(:color) ? resolve_color(options[:color]) : existing_event.color_id
+        timezone = resolve_timezone(options[:timezone], existing_event.timezone, options[:calendar])
+        recurrence = resolve_recurrence(options, existing_event)
+        transparency = resolve_transparency(options, existing_event)
 
         start_time = if options[:when]
           parse_start_time(options[:when])
@@ -127,8 +171,46 @@ module Rcal
           location: location,
           description: description,
           all_day: existing_event.all_day?,
-          calendar_id: existing_event.calendar_id
+          calendar_id: existing_event.calendar_id,
+          color_id: color_id,
+          timezone: timezone,
+          recurrence: recurrence,
+          transparency: transparency
+        )
+      end
+
+      def resolve_recurrence(options, existing_event)
+        return existing_event.recurrence unless options[:repeat]
+
+        # --repeat=none removes recurrence
+        return nil if options[:repeat].downcase == "none"
+
+        build_recurrence(options)
+      end
+
+      def build_recurrence(options)
+        RecurrenceBuilder.build(
+          freq: options[:repeat],
+          days: options[:days],
+          count: options[:count],
+          until_date: options[:until],
+          interval: options[:interval]
         )
+      rescue Rcal::Error => e
+        raise CLI::Kit::Abort, e.message
+      end
+
+      def resolve_timezone(timezone_input, existing_timezone, calendar_id)
+        # Explicit flag wins, then preserve existing event timezone, then resolve from calendar/system
+        timezone_input || existing_timezone || TimezoneResolver.resolve(calendar_id: calendar_id)
+      end
+
+      def resolve_color(color_input)
+        return nil if color_input.nil?
+
+        ColorMap.resolve(color_input)
+      rescue Rcal::Error => e
+        raise CLI::Kit::Abort, e.message
       end
 
       def parse_start_time(when_text)

data/lib/rcal/commands.rb

@@ -11,6 +11,7 @@ module Rcal
 
     register :Add, "add", "rcal/commands/add"
     register :Agenda, "agenda", "rcal/commands/agenda"
+    register :Colors, "colors", "rcal/commands/colors"
     register :Edit, "edit", "rcal/commands/edit"
     register :Help, "help", "rcal/commands/help"
     register :Import, "import", "rcal/commands/import"

data/lib/rcal/models/event.rb

@@ -4,7 +4,8 @@ module Rcal
   class Event
     attr_reader :id, :summary, :start_time, :end_time, :description,
       :location, :calendar_id, :transparency, :recurrence,
-      :recurring_event_id, :response_status, :attendees, :timezone
+      :recurring_event_id, :response_status, :attendees, :timezone,
+      :color_id
 
     def initialize(
       summary:,
@@ -20,7 +21,8 @@ module Rcal
       recurring_event_id: nil,
       response_status: nil,
       attendees: nil,
-      timezone: nil
+      timezone: nil,
+      color_id: nil
     )
       @id = id
       @summary = summary
@@ -36,6 +38,7 @@ module Rcal
       @response_status = response_status
       @attendees = normalize_attendees(attendees)
       @timezone = timezone
+      @color_id = color_id
     end
 
     def all_day?

data/lib/rcal/recurrence_builder.rb

@@ -0,0 +1,113 @@
+require_relative "errors"
+
+module Rcal
+  module RecurrenceBuilder
+    VALID_FREQUENCIES = %w[daily weekly monthly yearly].freeze
+
+    VALID_DAYS = %w[SU MO TU WE TH FR SA].freeze
+
+    # Maps full and abbreviated day names to RFC 5545 BYDAY abbreviations.
+    # Case-insensitive lookup via downcase key.
+    DAY_ALIASES = {
+      "sunday" => "SU", "sun" => "SU", "su" => "SU",
+      "monday" => "MO", "mon" => "MO", "mo" => "MO",
+      "tuesday" => "TU", "tue" => "TU", "tu" => "TU",
+      "wednesday" => "WE", "wed" => "WE", "we" => "WE",
+      "thursday" => "TH", "thu" => "TH", "th" => "TH",
+      "friday" => "FR", "fri" => "FR", "fr" => "FR",
+      "saturday" => "SA", "sat" => "SA", "sa" => "SA"
+    }.freeze
+
+    class << self
+      # Builds an RFC 5545 RRULE string from structured options.
+      #
+      # @param freq [String] Recurrence frequency: daily, weekly, monthly, yearly (required)
+      # @param days [String, nil] Comma-separated day names/abbreviations (e.g., "MO,WE,FR" or "Monday,Wed")
+      # @param count [String, Integer, nil] Number of occurrences
+      # @param until_date [String, nil] End date for recurrence (ISO 8601 or natural language date string)
+      # @param interval [String, Integer, nil] Repeat every N periods (default: 1, omitted when 1)
+      #
+      # @return [Array<String>] Single-element array with the RRULE string, e.g., ["RRULE:FREQ=WEEKLY;BYDAY=MO,WE;COUNT=10"]
+      # @raise [Rcal::Error] If options are invalid
+      def build(freq:, days: nil, count: nil, until_date: nil, interval: nil)
+        validate_freq!(freq)
+        validate_count_until_exclusivity!(count, until_date)
+
+        parts = ["FREQ=#{freq.upcase}"]
+
+        interval_val = parse_interval(interval)
+        parts << "INTERVAL=#{interval_val}" if interval_val && interval_val > 1
+        parts << "BYDAY=#{normalize_days(days).join(",")}" if days
+        parts << "COUNT=#{parse_count(count)}" if count
+        parts << "UNTIL=#{format_until(until_date)}" if until_date
+
+        ["RRULE:#{parts.join(";")}"]
+      end
+
+      private
+
+      def validate_freq!(freq)
+        unless VALID_FREQUENCIES.include?(freq.to_s.downcase)
+          raise Rcal::Error,
+            "Invalid recurrence frequency: #{freq}. " \
+            "Valid values: #{VALID_FREQUENCIES.join(", ")}"
+        end
+      end
+
+      def validate_count_until_exclusivity!(count, until_date)
+        if count && until_date
+          raise Rcal::Error, "Cannot specify both --count and --until. Use one or the other."
+        end
+      end
+
+      def normalize_days(days_input)
+        day_list = days_input.to_s.split(",").map(&:strip)
+
+        day_list.map do |day|
+          normalized = DAY_ALIASES[day.downcase]
+
+          if normalized.nil?
+            raise Rcal::Error,
+              "Invalid day: #{day}. " \
+              "Valid values: #{VALID_DAYS.join(", ")} (or full names like Monday, Tue, etc.)"
+          end
+
+          normalized
+        end
+      end
+
+      def parse_count(count)
+        val = count.to_i
+
+        unless val.positive?
+          raise Rcal::Error, "Count must be a positive integer, got: #{count}"
+        end
+
+        val
+      end
+
+      def parse_interval(interval)
+        return if interval.nil?
+
+        val = interval.to_i
+
+        unless val.positive?
+          raise Rcal::Error, "Interval must be a positive integer, got: #{interval}"
+        end
+
+        val
+      end
+
+      def format_until(until_date)
+        # Parse the date and format as YYYYMMDD for all-day style UNTIL,
+        # or YYYYMMDDTHHMMSSZ for datetime UNTIL.
+        # Google Calendar accepts both; we use the date-only form for simplicity.
+        date = Date.parse(until_date.to_s)
+        date.strftime("%Y%m%dT235959Z")
+      rescue Date::Error, ArgumentError
+        raise Rcal::Error,
+          "Could not parse until date: #{until_date}. Use a date like '2024-12-31'."
+      end
+    end
+  end
+end

data/lib/rcal/timezone_resolver.rb

@@ -0,0 +1,57 @@
+require_relative "calendar_service"
+
+module Rcal
+  module TimezoneResolver
+    # IANA timezone mappings for common Ruby Time#zone abbreviations.
+    # Ruby's Time#zone returns abbreviated names (e.g., "EST") which are
+    # ambiguous and not valid IANA identifiers. This maps the most common
+    # US/international abbreviations to their IANA equivalents.
+    ZONE_ABBREVIATIONS = {
+      "EST" => "America/New_York",
+      "EDT" => "America/New_York",
+      "CST" => "America/Chicago",
+      "CDT" => "America/Chicago",
+      "MST" => "America/Denver",
+      "MDT" => "America/Denver",
+      "PST" => "America/Los_Angeles",
+      "PDT" => "America/Los_Angeles",
+      "AKST" => "America/Anchorage",
+      "AKDT" => "America/Anchorage",
+      "HST" => "Pacific/Honolulu",
+      "UTC" => "Etc/UTC",
+      "GMT" => "Etc/GMT"
+    }.freeze
+
+    class << self
+      # Resolves the timezone to use for an event, using a layered approach:
+      #   1. Explicit timezone (from --timezone flag)
+      #   2. Calendar's default timezone (from Google Calendar API)
+      #   3. System local timezone (last resort fallback)
+      #
+      # Returns an IANA timezone string (e.g., "America/New_York").
+      def resolve(explicit: nil, calendar_id: nil)
+        explicit || calendar_timezone(calendar_id) || system_timezone
+      end
+
+      # Fetches the calendar's default timezone from the API.
+      # Returns nil on any failure (network error, missing calendar, etc.)
+      def calendar_timezone(calendar_id)
+        return if calendar_id.nil?
+
+        CalendarService.get_calendar(calendar_id: calendar_id)&.timezone
+      rescue => _e
+        nil
+      end
+
+      # Returns the system's local timezone as an IANA identifier.
+      # Tries ENV["TZ"] first, then falls back to mapping Ruby's
+      # Time#zone abbreviation.
+      def system_timezone
+        env_tz = ENV["TZ"]
+        return env_tz if env_tz && !env_tz.empty? && env_tz.include?("/")
+
+        ZONE_ABBREVIATIONS[Time.now.zone] || "Etc/UTC"
+      end
+    end
+  end
+end

data/lib/rcal/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Rcal
-  VERSION = "0.1.1"
+  VERSION = "0.2.0"
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: r_cal
 version: !ruby/object:Gem::Version
-  version: 0.1.1
+  version: 0.2.0
 platform: ruby
 authors:
 - Drew Bragg
@@ -277,10 +277,12 @@ files:
 - lib/rcal/adapters/ics_parser/icalendar.rb
 - lib/rcal/auth.rb
 - lib/rcal/calendar_service.rb
+- lib/rcal/color_map.rb
 - lib/rcal/command.rb
 - lib/rcal/commands.rb
 - lib/rcal/commands/add.rb
 - lib/rcal/commands/agenda.rb
+- lib/rcal/commands/colors.rb
 - lib/rcal/commands/edit.rb
 - lib/rcal/commands/help.rb
 - lib/rcal/commands/import.rb
@@ -299,6 +301,8 @@ files:
 - lib/rcal/predicate_collection.rb
 - lib/rcal/presenters/calendar_presenter.rb
 - lib/rcal/presenters/event_presenter.rb
+- lib/rcal/recurrence_builder.rb
+- lib/rcal/timezone_resolver.rb
 - lib/rcal/version.rb
 - mise.toml
 homepage: https://github.com/DRBragg/rcal