git-fit 0.9.9 → 0.10.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 3a908280d55da8ff10de61a53bfefa318d7838917604d73f30a906dc62702650
-  data.tar.gz: 8ed803dda5b4c5459235302c8fe8e22618575925aa3feab783781324ce3264d2
+  metadata.gz: 0d17d1744736bfa39aa88b5e914e7c312ec88fb9f10e33f8341082286473ffc9
+  data.tar.gz: ea386f48c48f9ebed0830509ab813c45b7359dd0063f3b7389b6e7e99575120e
 SHA512:
-  metadata.gz: 6887ca31b7ba22ba23608a2beda2898d4c80c64d726dfd2234c2f73d054d4e8c30cac4b529c187985b88c994a03bd5dc47bfc389856897965175e6f47ada22f7
-  data.tar.gz: '052090c32f37ea6f2a4219f187a514beb62a3ac61979796feda7e96c26aed18a7eceabe08c767ac34dc79e7916abb1e4d5df51e86d7c4c23ff3e8267d809ff33'
+  metadata.gz: 5af02664030285938853b892bc7fecef43cdff4ade002816525928dbfebc9f80dd9999d0dbadd1fe2da6ef38081ed67ee0eb69167c29d87349809e19ef60fd93
+  data.tar.gz: c94ba5c627f3c41227b6b9b3ede8af9ea2719ac977c7d4f672c7a8b258753466a08d5378737523c4ce79678c02100312bedc52b5134f573aaacff480556a8d4a

data/lib/git-fit.rb

@@ -82,4 +82,6 @@ require_relative 'git_fit/cli/gh_cli'
 require_relative 'git_fit/cli/export'
 require_relative 'git_fit/cli/import_cli'
 require_relative 'git_fit/cli/geo_cli'
+require_relative 'git_fit/strava_web/file_check'
+require_relative 'git_fit/cli/strava'
 require_relative 'git_fit/cli'

data/lib/git_fit/cli/export.rb

@@ -25,5 +25,39 @@ module GitFit
     rescue StandardError => e
       say_status :error, "JSON export failed: #{e.message}", :red
     end
+
+    desc 'csv', 'Export activities to CSV'
+    option :output, type: :string, aliases: '-o', desc: 'Output path'
+    option :activity, type: :array, desc: 'Filter by sport type', aliases: '--act'
+
+    def csv
+      config = git_fit_config
+      conn = GitFit::DB::Connection.new(config.db_path)
+      conn.migrate!
+      db = conn.db
+      path = options[:output] || config.export_config.dig('csv', 'path') || 'site/workouts.csv'
+      filter = options[:activity]&.map(&:strip)&.map(&:downcase)
+      count = Export::CSV.new(db: db, output: path, activity_filter: filter).call
+      say_status :done, "Exported #{count} activities to #{path}", :green
+    rescue StandardError => e
+      say_status :error, "CSV export failed: #{e.message}", :red
+    end
+
+    desc 'stats', 'Export activity statistics to JSON'
+    option :output, type: :string, aliases: '-o', desc: 'Output path'
+    option :activity, type: :array, desc: 'Filter by sport type', aliases: '--act'
+
+    def stats
+      config = git_fit_config
+      conn = GitFit::DB::Connection.new(config.db_path)
+      conn.migrate!
+      db = conn.db
+      path = options[:output] || config.export_config.dig('stats', 'path') || 'site/stats.json'
+      filter = options[:activity]&.map(&:strip)&.map(&:downcase)
+      count = Export::Stats.new(db: db, output: path, activity_filter: filter).call
+      say_status :done, "Exported stats for #{count} activities to #{path}", :green
+    rescue StandardError => e
+      say_status :error, "Stats export failed: #{e.message}", :red
+    end
   end
 end

data/lib/git_fit/cli/geo_cli.rb

@@ -11,7 +11,7 @@ module GitFit
     option :time,     type: :numeric, aliases: '-t', desc: 'Time budget in seconds'
     option :"dry-run", type: :boolean, desc: "Don't write to DB"
     option :checkpoint, type: :boolean, desc: 'Run WAL checkpoint after detect'
-    option :"cache-dir", type: :string, desc: "Geo cache directory (empty = no cache)", default: ""
+    option :"cache-dir", type: :string, desc: 'Geo cache directory (empty = no cache)', default: ''
     def detect
       config = GitFit::Config.new
         conn = GitFit::DB::Connection.new(config.db_path)

data/lib/git_fit/cli/strava.rb

@@ -0,0 +1,191 @@
+# frozen_string_literal: true
+
+require 'thor'
+require 'fileutils'
+require 'stravaweb'
+
+module GitFit
+  class StravaCLI < Thor
+    VALID_FORMATS = %w[original tcx gpx].freeze
+
+    TOKEN_HELP = <<~HELP
+      Token expired or invalid — generate a fresh one:
+        1. Open https://www.strava.com/login and sign in (email + OTP)
+        2. F12 → Application → Cookies → https://www.strava.com
+        3. Copy the Value of strava_remember_token
+        4. Configure it:
+           Local (config/config.yml):
+             sync.strava.web_auth.jwt: "<JWT>"
+           Env:
+             export GIT_FIT_STRAVA_WEB_AUTH_JWT="<JWT>"
+           CI (base64 secret):
+             echo -n "<JWT>" | base64 -w0 | gh secret set GIT_FIT_STRAVA_WEB_AUTH_AUTH_SEED
+      Token lifetime: ~30 days (JWT exp claim)
+    HELP
+
+    desc 'fetch [ID ...]', 'Download original files from Strava via web export'
+    option :jwt, type: :string, desc: 'JWT token for web auth (overrides config)'
+    option :format, type: :string, default: 'original', desc: 'Export format: original, tcx, or gpx'
+    option :output,
+           type: :string,
+           desc: 'Output directory override',
+           default: File.join('data', 'raw', 'strava')
+    option :limit, type: :numeric, default: 10, desc: 'Max activities per run (default: 10)'
+    option :db, type: :string, desc: 'Database path override'
+    long_desc <<~DESC
+      Download original activity files from Strava via the website export endpoint.
+
+      With explicit IDs:
+        git fit strava fetch 12345 67890
+
+      Without IDs — reads the database to find Strava-sourced activities
+      that don't yet have an original file:
+        git fit strava fetch
+
+      Auth via strava_remember_token JWT.
+    DESC
+    def fetch(*activity_ids)
+      format = options[:format].to_s.downcase
+      unless VALID_FORMATS.include?(format)
+        raise ArgumentError, "unknown --format '#{format}' (valid: #{VALID_FORMATS.join(', ')})"
+      end
+
+      config = git_fit_config
+      web_cfg = config.sync_config('strava')['web_auth'] || {}
+      jwt = options[:jwt] || web_cfg['jwt']
+      auth_seed = web_cfg['auth_seed']
+
+      output_dir = options[:output]
+      FileUtils.mkdir_p(output_dir)
+      cache_dir = File.join('data', 'cache', 'strava_downloads')
+      FileUtils.mkdir_p(cache_dir)
+      cookie_path = File.join('data', 'cache', 'strava_session.yml')
+
+      if activity_ids.empty?
+        activity_ids = pending_ids(config, output_dir)
+        return if activity_ids.nil?
+      end
+
+      client = build_client(jwt, auth_seed, cookie_path)
+      fmt_sym = format.to_sym
+      stats = { success: 0, skipped: 0, failed: 0, token_errors: 0 }
+
+      activity_ids.each do |aid|
+        process_activity(client, aid, output_dir, cache_dir, fmt_sym, stats)
+      end
+
+      client.persist_cookies!
+
+      say ''
+      say "fetch: #{stats[:success]} downloaded, #{stats[:skipped]} skipped, #{stats[:failed]} failed", :blue
+      say TOKEN_HELP, :yellow if stats[:token_errors] > 0 && stats[:success] == 0
+    end
+
+    private
+
+    def git_fit_config
+      @git_fit_config ||= GitFit::Config.new(options[:config])
+    end
+
+    def build_client(jwt, auth_seed, cookie_path)
+      ::StravaWeb::Fetch.new(jwt: jwt, auth_seed: auth_seed, cookie_path: cookie_path)
+    rescue ::StravaWeb::AuthError => e
+      say_status :error, "auth failed: #{e.message}", :red
+      say TOKEN_HELP, :yellow
+      exit 1
+    rescue Faraday::Error => e
+      say_status :error, "auth failed: network — #{e.message}", :red
+      exit 1
+    end
+
+    def pending_ids(config, output_dir)
+      db_path_val = options[:db] || config.db_path
+      all_ids = begin
+        conn = GitFit::DB::Connection.new(db_path_val)
+        conn.migrate!
+        conn.db[:activities]
+            .where(source: 'strava')
+            .select_map(:run_id)
+            .map { |rid| rid.sub('strava_', '') }
+      rescue Sequel::DatabaseError => e
+        say_status :error, "DB error: #{e.message}", :red
+        say_status :error, "Fix: rm -f #{db_path_val} && git fit db migrate", :yellow
+        exit 1
+      end
+
+      if all_ids.empty?
+        say 'No Strava activities in database.', :yellow
+        return nil
+      end
+
+      activity_ids = all_ids.reject do |id|
+        Dir.glob(File.join(output_dir, id, '*')).any?
+      end
+
+      if activity_ids.empty?
+        say "All #{all_ids.size} Strava activities already have original files.", :green
+        return nil
+      end
+
+      total = activity_ids.size
+      limit = options[:limit].to_i
+      if limit > 0 && activity_ids.size > limit
+        activity_ids = activity_ids.first(limit)
+        say "Limited to #{limit} of #{total} pending", :cyan
+      end
+
+      say "Found #{all_ids.size} Strava activities in DB, #{total} without original files", :cyan
+      activity_ids
+    end
+
+    def process_activity(client, aid, output_dir, cache_dir, fmt_sym, stats)
+      existing = Dir.glob(File.join(output_dir, aid, '*')).first
+
+      if existing
+        if StravaWeb::FileCheck.validate_existing_file(existing)
+          say "skip #{aid} (#{File.basename(existing)})", :yellow
+          stats[:skipped] += 1
+          return
+        else
+          say "warn #{aid}: existing file invalid — re-downloading", :yellow
+        end
+      end
+
+      begin
+        result = client.export(aid, format: fmt_sym)
+
+        unless result.content && !result.content.empty?
+          say "error #{aid}: empty response", :red
+          stats[:failed] += 1
+          return
+        end
+
+        unless StravaWeb::FileCheck.valid_format?(result.content, result.format)
+          say "error #{aid}: #{StravaWeb::FileCheck.describe_error(result.content)}", :red
+          stats[:failed] += 1
+          return
+        end
+
+        final_path = File.join(output_dir, aid, result.filename)
+        FileUtils.mkdir_p(File.dirname(final_path))
+        ext = result.format.to_s
+        temp_path = File.join(cache_dir, "#{aid}.#{ext}")
+
+        File.write(temp_path, result.content, mode: 'wb')
+        FileUtils.mv(temp_path, final_path)
+        say "ok #{aid}  #{result.filename} (#{result.format})", :green
+        stats[:success] += 1
+      rescue ::StravaWeb::NotFoundError
+        say "skip #{aid}: no original file on Strava (HTTP 404)", :yellow
+        stats[:skipped] += 1
+      rescue ::StravaWeb::ExportError => e
+        stats[:token_errors] += 1 if e.message.include?('HTTP 401') || e.message.include?('HTTP 403')
+        say "fail #{aid}: #{e.message}", :red
+        stats[:failed] += 1
+      rescue Faraday::Error => e
+        say "fail #{aid}: network — #{e.class}: #{e.message}", :red
+        stats[:failed] += 1
+      end
+    end
+  end
+end

data/lib/git_fit/cli.rb

@@ -78,6 +78,9 @@ module GitFit
     desc 'geo SUBCOMMAND', 'Detect geographical administrative regions'
     subcommand 'geo', GeoCLI
 
+    desc 'strava SUBCOMMAND', 'Strava web operations'
+    subcommand 'strava', StravaCLI
+
     desc 'install SUBCOMMAND', 'Install project assets (actions)'
     subcommand 'install', InstallCLI
 

data/lib/git_fit/config.rb

@@ -14,6 +14,7 @@ module GitFit
       },
       'export' => {
         'json' => { 'path' => 'site/activities.json' },
+        'stats' => { 'path' => 'site/stats.json' },
         'svg' => { 'dir' => 'site/svg' },
         'csv' => { 'path' => 'site/workouts.csv' },
         'gpx' => { 'path' => 'site/gpx_out' },
@@ -86,9 +87,10 @@ module GitFit
 
       GitFit.registered_configs.each do |reg|
         reg[:keys].each do |key|
-          env_name = "#{reg[:prefix]}_#{key.to_s.upcase}"
+          segments = key.is_a?(Array) ? key.map(&:to_s) : [key.to_s]
+          env_name = "#{reg[:prefix]}_#{segments.join('_').upcase}"
           next unless ENV.key?(env_name)
-          set_nested(@data, reg[:config_path] + [key.to_s], ENV[env_name])
+          set_nested(@data, reg[:config_path] + segments, ENV[env_name])
         end
       end
     end

data/lib/git_fit/config_template.rb

@@ -16,6 +16,9 @@ module GitFit
           # strava:                                    # env: GIT_FIT_STRAVA_CLIENT_ID
           #   client_id: ""                            # env: GIT_FIT_STRAVA_CLIENT_SECRET
           #   refresh_token: ""                        # env: GIT_FIT_STRAVA_REFRESH_TOKEN
+          #   web_auth:                                # web original-file fetch (git fit strava fetch)
+          #     jwt: ""                                # env: GIT_FIT_STRAVA_WEB_AUTH_JWT (strava_remember_token)
+          #     auth_seed: ""                          # env: GIT_FIT_STRAVA_WEB_AUTH_AUTH_SEED (base64 JWT)
 
           # garmin:                                    # env: GIT_FIT_GARMIN_EMAIL
           #   email: ""                                # env: GIT_FIT_GARMIN_PASSWORD
@@ -44,6 +47,9 @@ module GitFit
           json:
             path: site/activities.json
 
+          # csv:
+          #   path: site/workouts.csv
+
         privacy:
           start_end_range: 200
 

data/lib/git_fit/export/calculator.rb

@@ -0,0 +1,233 @@
+# frozen_string_literal: true
+
+require 'date'
+
+module GitFit
+  module Export
+    class Calculator
+      def initialize(db:, activity_filter: nil)
+        @db = db
+        @activity_filter = activity_filter
+      end
+
+      def call
+        ds = @db[:activities]
+        ds = ds.where(sport_category: @activity_filter) if @activity_filter
+
+        all = ds.all
+        return empty_stats if all.empty?
+
+        {
+          summary: compute_summary(all),
+          monthly: compute_monthly(all),
+          yearly: compute_yearly(all),
+          streaks: compute_streaks(all),
+          activity_types: distinct_categories(all),
+        }
+      end
+
+      private
+
+      def empty_stats
+        { summary: {}, monthly: [], yearly: [], streaks: {}, activity_types: [] }
+      end
+
+      def compute_summary(rows)
+        total_dist = 0.0
+        total_time = 0
+        total_elev = 0.0
+        breakdown = Hash.new { |h, k| h[k] = { count: 0, distance_km: 0.0, moving_time_h: 0.0 } }
+
+        rows.each do |r|
+          cat = r[:sport_category] || 'other'
+          d = r[:distance] || 0
+          t = r[:moving_time] || 0
+          e = r[:elevation_gain] || 0
+
+          total_dist += d
+          total_time += t
+          total_elev += e
+
+          breakdown[cat][:count] += 1
+          breakdown[cat][:distance_km] += d / 1000.0
+          breakdown[cat][:moving_time_h] += t / 3600.0
+        end
+
+        cadences = rows.map { |r| r[:average_cadence] }.compact
+        powers = rows.map { |r| r[:average_power] }.compact
+
+        grouped_run_ids = if @db.table_exists?(:dedup_group_members)
+                            @db[:dedup_group_members].select_map(:run_id)
+                          else
+                            []
+                          end
+        unique = rows.reject { |a| grouped_run_ids.include?(a[:run_id]) }
+        unique_count = unique.size + (@db.table_exists?(:dedup_groups) ? @db[:dedup_groups].count : 0)
+
+        {
+          total_activities: rows.size,
+          unique_activities: unique_count,
+          total_distance_km: total_dist / 1000.0,
+          total_moving_time_h: total_time / 3600.0,
+          total_elevation_gain_m: total_elev,
+          avg_cadence: cadences.any? ? (cadences.sum / cadences.size).round(1) : nil,
+          avg_power: powers.any? ? (powers.sum / powers.size).round(1) : nil,
+          sport_breakdown: breakdown.sort_by { |_, v| -v[:count] }.map do |cat, v|
+            { category: cat, count: v[:count], distance_km: v[:distance_km].round(1),
+              moving_time_h: v[:moving_time_h].round(1) }
+          end,
+        }
+      end
+
+      def compute_monthly(rows)
+        monthly = Hash.new do |h, k|
+          h[k] = { count: 0, distance_km: 0.0, moving_time_h: 0.0,
+                   total_hr: 0.0, hr_count: 0, total_elev: 0.0,
+                   total_cadence: 0.0, cadence_count: 0,
+                   total_power: 0.0, power_count: 0 }
+        end
+
+        rows.each do |r|
+          next unless r[:start_date_local] || r[:start_date]
+
+          ym = (r[:start_date_local] || r[:start_date])[0..6]
+          d = r[:distance] || 0
+          t = r[:moving_time] || 0
+          hr = r[:average_heartrate]
+          e = r[:elevation_gain] || 0
+
+          monthly[ym][:count] += 1
+          monthly[ym][:distance_km] += d / 1000.0
+          monthly[ym][:moving_time_h] += t / 3600.0
+          monthly[ym][:total_elev] += e
+          if hr && hr > 0
+            monthly[ym][:total_hr] += hr
+            monthly[ym][:hr_count] += 1
+          end
+          cad = r[:average_cadence]
+          pow = r[:average_power]
+          if cad && cad > 0
+            monthly[ym][:total_cadence] += cad
+            monthly[ym][:cadence_count] += 1
+          end
+          if pow && pow > 0
+            monthly[ym][:total_power] += pow
+            monthly[ym][:power_count] += 1
+          end
+        end
+
+        monthly.sort.map do |ym, v|
+          pace = if v[:moving_time_h] > 0 && v[:distance_km] > 0
+                   format_pace(v[:moving_time_h] * 3600 / v[:distance_km])
+                 end
+          {
+            year: ym[0..3].to_i,
+            month: ym[5..6].to_i,
+            count: v[:count],
+            distance_km: v[:distance_km].round(1),
+            moving_time_h: v[:moving_time_h].round(1),
+            avg_pace: pace,
+            avg_hr: v[:hr_count] > 0 ? (v[:total_hr] / v[:hr_count]).round(0) : nil,
+            avg_cadence: v[:cadence_count] > 0 ? (v[:total_cadence] / v[:cadence_count]).round(0) : nil,
+            avg_power: v[:power_count] > 0 ? (v[:total_power] / v[:power_count]).round(0) : nil,
+            elevation_gain_m: v[:total_elev].round(0),
+          }
+        end
+      end
+
+      def compute_yearly(rows)
+        by_year = Hash.new { |h, k| h[k] = [] }
+        rows.each do |r|
+          next unless r[:start_date_local] || r[:start_date]
+          by_year[(r[:start_date_local] || r[:start_date])[0..3].to_i] << r
+        end
+
+        by_year.sort.map do |year, acts|
+          total_dist = acts.sum { |r| r[:distance] || 0 } / 1000.0
+          total_time = acts.sum { |r| r[:moving_time] || 0 }
+          longest = acts.map { |r| r[:distance] || 0 }.max / 1000.0
+
+          streak = calculate_streak(acts)
+
+          { year: year, count: acts.size, distance_km: total_dist.round(1),
+            moving_time_h: (total_time / 3600.0).round(1),
+            longest_km: longest.round(1), streak: streak }
+        end
+      end
+
+      def compute_streaks(rows)
+        dates = rows.filter_map do |r|
+          next nil unless r[:start_date_local] || r[:start_date]
+          begin
+            Date.parse(r[:start_date_local] || r[:start_date])
+          rescue StandardError
+            nil
+          end
+        end.uniq.sort
+
+        return { current: 0, all_time: 0, year_max: {} } if dates.empty?
+
+        max_streak = 1
+        current_streak = 1
+
+        (1...dates.length).each do |i|
+          if (dates[i] - dates[i - 1]).to_i == 1
+            current_streak += 1
+            max_streak = current_streak if current_streak > max_streak
+          else
+            current_streak = 1
+          end
+        end
+
+        today = Date.today
+        current = if dates.last == today || dates.last == today - 1
+                    streak = 1
+                    j = dates.length - 2
+                    while j >= 0 && (dates[j + 1] - dates[j]).to_i == 1
+                      streak += 1
+                      j -= 1
+                    end
+                    streak
+                  else
+                    0
+                  end
+
+        { current: current, all_time: max_streak }
+      end
+
+      def distinct_categories(rows)
+        rows.map { |r| r[:sport_category] }.uniq.compact.sort
+      end
+
+      def format_pace(sec_per_km)
+        min = (sec_per_km / 60).to_i
+        sec = sec_per_km.to_i % 60
+        "#{min}'#{format('%02d', sec)}\""
+      end
+
+      def calculate_streak(rows)
+        dates = rows.filter_map do |r|
+          next nil unless r[:start_date_local] || r[:start_date]
+          begin
+            Date.parse(r[:start_date_local] || r[:start_date])
+          rescue StandardError
+            nil
+          end
+        end.uniq.sort
+        return 0 if dates.empty?
+
+        max_s = 1
+        cur = 1
+        (1...dates.length).each do |i|
+          if (dates[i] - dates[i - 1]).to_i == 1
+            cur += 1
+            max_s = cur if cur > max_s
+          else
+            cur = 1
+          end
+        end
+        max_s
+      end
+    end
+  end
+end

data/lib/git_fit/export/csv.rb

@@ -0,0 +1,44 @@
+# frozen_string_literal: true
+
+require 'csv'
+
+module GitFit
+  module Export
+    class CSV
+      HEADERS = %w[
+        run_id name distance moving_time elapsed_time
+        sport_category sport_type start_date start_date_local
+        location_country summary_polyline
+        average_heartrate max_heartrate average_cadence max_cadence
+        average_power max_power calories average_temperature
+        average_speed elevation_gain source dedup_group_id
+      ].freeze
+
+      def initialize(db:, output:, activity_filter: nil)
+        @db = db
+        @output = output
+        @activity_filter = activity_filter
+      end
+
+      def call
+        run_id_to_group = {}
+        @db[:dedup_group_members].each { |gm| run_id_to_group[gm[:run_id]] = gm[:group_id] }
+
+        dataset = @db[:activities].order(Sequel.desc(:start_date))
+        dataset = dataset.where(sport_category: @activity_filter) if @activity_filter
+
+        count = 0
+        ::CSV.open(@output, 'w') do |csv|
+          csv << HEADERS
+          dataset.each do |a|
+            row = HEADERS[0...-1].map { |h| a[h.to_sym] }
+            row << run_id_to_group[a[:run_id]]
+            csv << row
+            count += 1
+          end
+        end
+        count
+      end
+    end
+  end
+end

data/lib/git_fit/export/stats.rb

@@ -0,0 +1,22 @@
+# frozen_string_literal: true
+
+require 'json'
+
+module GitFit
+  module Export
+    class Stats
+      def initialize(db:, output:, activity_filter: nil)
+        @db = db
+        @output = output
+        @activity_filter = activity_filter
+      end
+
+      def call
+        calculator = Calculator.new(db: @db, activity_filter: @activity_filter)
+        stats = calculator.call
+        File.write(@output, ::JSON.pretty_generate(stats))
+        stats[:summary][:total_activities] || 0
+      end
+    end
+  end
+end

data/lib/git_fit/export.rb

@@ -7,3 +7,6 @@ end
 
 require_relative 'export/defaults'
 require_relative 'export/json'
+require_relative 'export/csv'
+require_relative 'export/calculator'
+require_relative 'export/stats'

data/lib/git_fit/strava_web/file_check.rb

@@ -0,0 +1,61 @@
+# frozen_string_literal: true
+
+require 'json'
+
+module GitFit
+  module StravaWeb
+    # Content validation for downloaded Strava files (FIT/TCX/GPX/JSON).
+    module FileCheck
+      module_function
+
+      def valid_format?(content, format)
+        case format
+        when :fit
+          content[0, 64].include?('.FIT'.b) || content.start_with?("\x0E\x10".b)
+        when :tcx
+          content.include?('TrainingCenterDatabase'.b)
+        when :gpx
+          content.include?('<gpx'.b)
+        when :json
+          JSON.parse(content)
+          true
+        else
+          !content.empty?
+        end
+      rescue StandardError
+        false
+      end
+
+      def validate_existing_file(path)
+        return false unless File.exist?(path) && File.size(path) > 0
+
+        content = File.read(path, mode: 'rb', length: 4096)
+        case File.extname(path).downcase
+        when '.fit'
+          content.start_with?("\x0E\x10".b)
+        when '.tcx'
+          content.include?('TrainingCenterDatabase'.b)
+        when '.gpx'
+          content.include?('<gpx'.b)
+        when '.json'
+          JSON.parse(content)
+          true
+        else
+          !content.empty?
+        end
+      rescue StandardError
+        false
+      end
+
+      def describe_error(content)
+        head = content[0, 200].b
+        if head.include?('<html') || head.include?('<!DOCTYPE')
+          "Strava returned HTML (likely rate-limit or auth page) — #{content.length} bytes"
+        else
+          sample = content[0, 80].force_encoding('UTF-8').scrub('?')
+          "unexpected content format — #{sample}"
+        end
+      end
+    end
+  end
+end

data/lib/git_fit/sync/strava.rb

@@ -11,7 +11,8 @@ module GitFit
       BASE_URL = 'https://www.strava.com/api/v3'
 
       register_adapter
-      register_config :client_id, :client_secret, :refresh_token
+      register_config :client_id, :client_secret, :refresh_token,
+                      %w[web_auth jwt], %w[web_auth auth_seed]
 
       def authenticate
         return false unless @config['client_id'].to_s != '' &&

data/lib/git_fit/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module GitFit
-  VERSION = '0.9.9'
+  VERSION = '0.10.0'
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: git-fit
 version: !ruby/object:Gem::Version
-  version: 0.9.9
+  version: 0.10.0
 platform: ruby
 authors:
 - Lax
@@ -135,6 +135,20 @@ dependencies:
     - - "~>"
       - !ruby/object:Gem::Version
         version: '2.0'
+- !ruby/object:Gem::Dependency
+  name: stravaweb
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.0'
 - !ruby/object:Gem::Dependency
   name: oauth
   requirement: !ruby/object:Gem::Requirement
@@ -177,6 +191,20 @@ dependencies:
     - - "~>"
       - !ruby/object:Gem::Version
         version: '0.6'
+- !ruby/object:Gem::Dependency
+  name: csv
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.0'
 description: A git extension CLI for aggregating, managing, and exporting fitness
   activity data from multiple sources (Garmin, Strava, Keep, etc.)
 email:
@@ -196,6 +224,7 @@ files:
 - lib/git_fit/cli/gh_cli.rb
 - lib/git_fit/cli/import_cli.rb
 - lib/git_fit/cli/install_cli.rb
+- lib/git_fit/cli/strava.rb
 - lib/git_fit/cli/sync.rb
 - lib/git_fit/config.rb
 - lib/git_fit/config_template.rb
@@ -204,8 +233,11 @@ files:
 - lib/git_fit/db/connection.rb
 - lib/git_fit/db/rebuild.rb
 - lib/git_fit/export.rb
+- lib/git_fit/export/calculator.rb
+- lib/git_fit/export/csv.rb
 - lib/git_fit/export/defaults.rb
 - lib/git_fit/export/json.rb
+- lib/git_fit/export/stats.rb
 - lib/git_fit/fit.rb
 - lib/git_fit/fit/decoder.js
 - lib/git_fit/fit/decoder.rb
@@ -232,6 +264,7 @@ files:
 - lib/git_fit/source/base.rb
 - lib/git_fit/source/tally.rb
 - lib/git_fit/sport_mapper.rb
+- lib/git_fit/strava_web/file_check.rb
 - lib/git_fit/sync/base.rb
 - lib/git_fit/sync/garmin.rb
 - lib/git_fit/sync/garmin_base.rb