git-fit 0.1.1 → 0.3.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 9551667addc842c5ddb8357d32b9d4eb040eedc236eeb3c940f59ea52f8be329
-  data.tar.gz: 3ede4c5df18fd6a3380b5aff8845bf2ac1ca7d1074c2507e647e05363bf745fb
+  metadata.gz: 66005a7ca77d10a5922f57d085f4354c3ec4b0838faf350b9b2533e1159b7870
+  data.tar.gz: 783823d2e2e2b8031572527afdaaa8a5b2b06491b9a98f07671147233609c315
 SHA512:
-  metadata.gz: 437969ed9c1dd8ec94de2449cbe8e71e8201bcfe2299fd3dcdcf44c8ae6b4901482b99fdd3459482395896a10c96c455a1acff8c69fd2e242c81e1befdb88941
-  data.tar.gz: 11ffe29a5aecb4c305f361c81ad3eef6f73394fc9abb00f75486d68a32caac3de565ef941236120622b63c61059b20486f790e32290ef016da93141266d20b5e
+  metadata.gz: c89175b5dc5c16ac6def3cf27bb5a9ed3019f3bd0eeac32667948e36449eb3f3f2cf398a76106314be790587233396da65c7f278665c6de92284597d6870f6c4
+  data.tar.gz: 6de6c3ed115ce17df85754c0c2d90e8ce069fc91e86593ade7061ee64acdeb3661903667680fb26a4604a4eadf57c5c9b7f8832b3bdd5648d7b15ca0aebd8091

data/lib/git-fit.rb

@@ -3,6 +3,8 @@ require "yaml"
 require "fileutils"
 
 module GitFit
+  SPORT_CATEGORIES = %w[run ride hike walk swim ski workout other].freeze
+
   @registered_configs = []
 
   class << self
@@ -11,12 +13,49 @@ module GitFit
     def register_config_source(prefix:, keys:, config_path:)
       @registered_configs << { prefix: prefix, keys: keys, config_path: config_path }
     end
+
+    def activity_to_hash(a)
+      return nil unless a
+
+      {
+        run_id: a[:run_id],
+        name: a[:name],
+        distance: a[:distance],
+        moving_time: format_time(a[:moving_time]),
+        type: a[:sport_category],
+        subtype: a[:sport_type],
+        start_date: a[:start_date],
+        start_date_local: a[:start_date_local],
+        location_country: a[:location_country],
+        summary_polyline: a[:summary_polyline],
+        average_heartrate: a[:average_heartrate],
+        average_speed: a[:average_speed],
+        elevation_gain: a[:elevation_gain]
+      }
+    end
+
+    def format_time(seconds)
+      return nil unless seconds
+      hours = seconds / 3600
+      minutes = (seconds % 3600) / 60
+      secs = seconds % 60
+      format("%d:%02d:%02d", hours, minutes, secs)
+    end
   end
 end
 
 require_relative "git_fit/version"
 require_relative "git_fit/config"
 require_relative "git_fit/config_template"
+require_relative "git_fit/sport_mapper"
+require_relative "git_fit/geo"
+require_relative "git_fit/fit"
+require_relative "git_fit/parser"
+require_relative "git_fit/timezone/resolver"
+require_relative "git_fit/privacy/polyline_filter"
 require_relative "git_fit/sync/base"
 require_relative "git_fit/sync/strava"
+require_relative "git_fit/db/connection"
+require_relative "git_fit/db/activity"
+require_relative "git_fit/db/cli"
 require_relative "git_fit/cli"

data/lib/git_fit/cli.rb

@@ -10,11 +10,51 @@ module GitFit
       true
     end
 
+    desc "db SUBCOMMAND", "Database operations"
+    subcommand "db", DB::CLI
+
     desc "version", "Show version"
     def version
       puts "git-fit v#{GitFit::VERSION}"
     end
 
+    desc "parse FILE", "Parse a GPX or TCX file"
+    option :save, type: :boolean, desc: "Save parsed activities to database", aliases: "-s"
+    def parse(file)
+      format = file.match?(/\.gpx$/i) ? :gpx : :tcx
+      content = File.read(file)
+      parser = format == :gpx ? GitFit::Parser::GPX.new(source: "file") : GitFit::Parser::TCX.new(source: "file")
+      activities = parser.call(content)
+
+      if activities.empty?
+        say_status :warn, "No activities found in #{file}", :yellow
+        return
+      end
+
+      activities.each do |act|
+        say_status :activity, act[:name] || "unnamed", :green
+        say "  #{act[:sport_category]}#{act[:sport_type] ? " (#{act[:sport_type]})" : ""}"
+        say "  #{act[:start_date]} | #{act[:distance]&.round(2)}m" if act[:distance]
+        say "  #{act[:moving_time]}s" if act[:moving_time]
+      end
+
+      if options[:save]
+        db = connect_db
+        now = Time.now.utc
+        activities.each do |act|
+          existing = db[:activities].where(run_id: act[:run_id]).first
+          if existing
+            db[:activities].where(run_id: act[:run_id]).update(act.merge(updated_at: now))
+          else
+            db[:activities].insert(act.merge(created_at: now, updated_at: now))
+          end
+        end
+        say_status :done, "Saved #{activities.size} activities", :green
+      end
+    rescue => e
+      say_status :error, "Parse failed: #{e.message}", :red
+    end
+
     desc "init", "Generate config.yml"
     option :output, type: :string, desc: "Output path", aliases: "-o"
     def init
@@ -49,6 +89,10 @@ module GitFit
         result
       end
 
+      def connect_db
+        GitFit::DB::Connection.new(git_fit_config.db_path).db
+      end
+
       def deep_dup(obj)
         case obj
         when Hash then obj.each_with_object({}) { |(k, v), h| h[k] = deep_dup(v) }

data/lib/git_fit/db/activity.rb

@@ -0,0 +1,15 @@
+# Deprecated: use GitFit.activity_to_hash / GitFit.format_time instead.
+# Kept for backward compatibility during migration.
+module GitFit
+  module DB
+    SPORT_CATEGORIES = GitFit::SPORT_CATEGORIES
+
+    def self.activity_to_hash(a)
+      GitFit.activity_to_hash(a)
+    end
+
+    def self.format_time(seconds)
+      GitFit.format_time(seconds)
+    end
+  end
+end

data/lib/git_fit/db/cli.rb

@@ -0,0 +1,16 @@
+require "thor"
+
+module GitFit
+  module DB
+    class CLI < Thor
+      desc "migrate", "Run database migrations"
+      def migrate
+        config = GitFit::Config.new
+        GitFit::DB::Connection.new(config.db_path)
+        say_status :done, "Migrations up to date", :green
+      rescue => e
+        say_status :error, "Migration failed: #{e.message}", :red
+      end
+    end
+  end
+end

data/lib/git_fit/db/connection.rb

@@ -0,0 +1,27 @@
+require "fileutils"
+require "sequel"
+
+module GitFit
+  module DB
+    class Connection
+      def initialize(db_path)
+        FileUtils.mkdir_p(File.dirname(db_path)) if db_path.include?("/")
+        @db = Sequel.sqlite(db_path)
+        @db.run("PRAGMA journal_mode=WAL")
+        @db.run("PRAGMA busy_timeout=5000")
+        run_migrations
+      end
+
+      def db
+        @db
+      end
+
+      private
+
+      def run_migrations
+        Sequel.extension :migration
+        Sequel::Migrator.run(@db, File.expand_path("../../../db/migrations", __dir__))
+      end
+    end
+  end
+end

data/lib/git_fit/fit/decoder.rb

@@ -0,0 +1,27 @@
+require "mini_racer"
+require "json"
+
+module GitFit
+  module FIT
+    class Decoder
+      JS_CODE = File.read(File.join(__dir__, "decoder.js")).freeze
+      CTX = MiniRacer::Context.new.tap { |c| c.eval(JS_CODE) }
+
+      def self.decode(path)
+        bytes = File.read(path, mode: "rb").bytes
+        json = CTX.eval("FitDecoder.decodeFit(#{bytes.inspect})")
+        records = JSON.parse(json)
+        records.each do |r|
+          r["positionLat"] *= 180 if r["positionLat"]
+          r["positionLong"] *= 180 if r["positionLong"]
+        end
+        records
+      end
+
+      def self.sport(path)
+        bytes = File.read(path, mode: "rb").bytes
+        CTX.eval("FitDecoder.fitSport(#{bytes.inspect})")
+      end
+    end
+  end
+end

data/lib/git_fit/fit.rb

@@ -0,0 +1 @@
+require_relative "fit/decoder"

data/lib/git_fit/geo/coord_transform.rb

@@ -0,0 +1,101 @@
+module GitFit
+  module Geo
+    # 3 coordinate systems: WGS84 (GPS native), GCJ-02 (China offset), BD-09 (Baidu).
+    module CoordTransform
+      A = 6378245.0
+      EE = 0.00669342162296594323
+
+      X_PI = Math::PI * 3000.0 / 180.0
+
+      module_function
+
+      def wgs84_to_gcj02(lat, lng)
+        return [lat, lng] if out_of_china(lng, lat)
+        dlat, dlng = delta(lat, lng)
+        [lat + dlat, lng + dlng]
+      end
+
+      def gcj02_to_wgs84(lat, lng)
+        return [lat, lng] if out_of_china(lng, lat)
+        dlat, dlng = delta(lat, lng)
+        [lat - dlat, lng - dlng]
+      end
+
+      def gcj02_to_wgs84_exact(lat, lng)
+        return [lat, lng] if out_of_china(lng, lat)
+        init_lat = lat
+        init_lng = lng
+        5.times do
+          dlat, dlng = delta(init_lat, init_lng)
+          init_lat = lat - dlat
+          init_lng = lng - dlng
+        end
+        [init_lat, init_lng]
+      end
+
+      def gcj02_to_bd09(lat, lng)
+        return [lat, lng] if out_of_china(lng, lat)
+        x = lng
+        y = lat
+        z = Math.sqrt(x * x + y * y) + 0.00002 * Math.sin(y * X_PI)
+        theta = Math.atan2(y, x) + 0.000003 * Math.cos(x * X_PI)
+        bd_lng = z * Math.cos(theta) + 0.0065
+        bd_lat = z * Math.sin(theta) + 0.006
+        [bd_lat, bd_lng]
+      end
+
+      def bd09_to_gcj02(lat, lng)
+        return [lat, lng] if out_of_china(lng, lat)
+        x = lng - 0.0065
+        y = lat - 0.006
+        z = Math.sqrt(x * x + y * y) - 0.00002 * Math.sin(y * X_PI)
+        theta = Math.atan2(y, x) - 0.000003 * Math.cos(x * X_PI)
+        gcj_lng = z * Math.cos(theta)
+        gcj_lat = z * Math.sin(theta)
+        [gcj_lat, gcj_lng]
+      end
+
+      def bd09_to_wgs84(lat, lng)
+        gcj_lat, gcj_lng = bd09_to_gcj02(lat, lng)
+        gcj02_to_wgs84_exact(gcj_lat, gcj_lng)
+      end
+
+      def wgs84_to_bd09(lat, lng)
+        gcj_lat, gcj_lng = wgs84_to_gcj02(lat, lng)
+        gcj02_to_bd09(gcj_lat, gcj_lng)
+      end
+
+      def out_of_china(lng, lat)
+        lng < 72.004 || lng > 137.8347 || lat < 0.8293 || lat > 55.8271
+      end
+
+      def delta(lat, lng)
+        dlat = transform_lat(lng - 105.0, lat - 35.0)
+        dlng = transform_lng(lng - 105.0, lat - 35.0)
+        radlat = lat / 180.0 * Math::PI
+        magic = Math.sin(radlat)
+        magic = 1 - EE * magic * magic
+        sqrt_magic = Math.sqrt(magic)
+        dlat = (dlat * 180.0) / ((A * (1 - EE)) / (magic * sqrt_magic) * Math::PI)
+        dlng = (dlng * 180.0) / (A / sqrt_magic * Math.cos(radlat) * Math::PI)
+        [dlat, dlng]
+      end
+
+      def transform_lat(x, y)
+        ret = -100.0 + 2.0 * x + 3.0 * y + 0.2 * y * y + 0.1 * x * y + 0.2 * Math.sqrt(x.abs)
+        ret += (20.0 * Math.sin(6.0 * x * Math::PI) + 20.0 * Math.sin(2.0 * x * Math::PI)) * 2.0 / 3.0
+        ret += (20.0 * Math.sin(y * Math::PI) + 40.0 * Math.sin(y / 3.0 * Math::PI)) * 2.0 / 3.0
+        ret += (160.0 * Math.sin(y / 12.0 * Math::PI) + 320.0 * Math.sin(y * Math::PI / 30.0)) * 2.0 / 3.0
+        ret
+      end
+
+      def transform_lng(x, y)
+        ret = 300.0 + x + 2.0 * y + 0.1 * x * x + 0.1 * x * y + 0.1 * Math.sqrt(x.abs)
+        ret += (20.0 * Math.sin(6.0 * x * Math::PI) + 20.0 * Math.sin(2.0 * x * Math::PI)) * 2.0 / 3.0
+        ret += (20.0 * Math.sin(x * Math::PI) + 40.0 * Math.sin(x / 3.0 * Math::PI)) * 2.0 / 3.0
+        ret += (150.0 * Math.sin(x / 12.0 * Math::PI) + 300.0 * Math.sin(x / 30.0 * Math::PI)) * 2.0 / 3.0
+        ret
+      end
+    end
+  end
+end

data/lib/git_fit/geo/polyline.rb

@@ -0,0 +1,78 @@
+module GitFit
+  module Geo
+    module Polyline
+      module_function
+
+      def decode(str)
+        return nil unless str && str.length > 0
+
+        points = []
+        index = 0
+        lat = 0
+        lng = 0
+
+        while index < str.length
+          shift = 0
+          result = 0
+          begin
+            byte = str[index].ord - 63
+            index += 1
+            result |= (byte & 0x1f) << shift
+            shift += 5
+          end while byte >= 0x20
+
+          dlat = (result & 1) != 0 ? ~(result >> 1) : (result >> 1)
+          lat += dlat
+
+          shift = 0
+          result = 0
+          begin
+            byte = str[index].ord - 63
+            index += 1
+            result |= (byte & 0x1f) << shift
+            shift += 5
+          end while byte >= 0x20
+
+          dlng = (result & 1) != 0 ? ~(result >> 1) : (result >> 1)
+          lng += dlng
+
+          points << [lat * 1e-5, lng * 1e-5]
+        end
+
+        points
+      end
+
+      def encode(points)
+        result = ""
+        plat = 0
+        plng = 0
+
+        points.each do |lat, lng|
+          dlat = ((lat * 1e5).round - plat)
+          dlng = ((lng * 1e5).round - plng)
+
+          plat += dlat
+          plng += dlng
+
+          result += encode_number(dlat)
+          result += encode_number(dlng)
+        end
+
+        result
+      end
+
+      def encode_number(num)
+        num = num < 0 ? ~(num << 1) : (num << 1)
+        result = ""
+
+        while num >= 0x20
+          result += ((0x20 | (num & 0x1f)) + 63).chr
+          num >>= 5
+        end
+
+        result += (num + 63).chr
+        result
+      end
+    end
+  end
+end

data/lib/git_fit/geo.rb

@@ -0,0 +1,7 @@
+module GitFit
+  module Geo
+  end
+end
+
+require_relative "geo/polyline"
+require_relative "geo/coord_transform"

data/lib/git_fit/parser/base.rb

@@ -0,0 +1,128 @@
+require "time"
+
+module GitFit
+  module Parser
+    class Base
+      def initialize(source: nil)
+        @source_name = source
+      end
+
+      def call(_input)
+        raise NotImplementedError
+      end
+
+      private
+
+      def haversine(p1, p2)
+        lat1 = deg_to_rad(p1[0])
+        lat2 = deg_to_rad(p2[0])
+        dlat = deg_to_rad(p2[0] - p1[0])
+        dlon = deg_to_rad(p2[1] - p1[1])
+        a = Math.sin(dlat / 2) ** 2 +
+            Math.cos(lat1) * Math.cos(lat2) *
+            Math.sin(dlon / 2) ** 2
+        c = 2 * Math.atan2(Math.sqrt(a), Math.sqrt(1 - a))
+        6371000.0 * c
+      end
+
+      def deg_to_rad(deg)
+        deg * Math::PI / 180.0
+      end
+
+      def total_distance(points)
+        return 0.0 if points.length < 2
+        (1...points.length).sum { |i| haversine(points[i - 1], points[i]) }
+      end
+
+      def elevation_gain(points)
+        return 0.0 if points.length < 2
+        (1...points.length).sum do |i|
+          elev1 = points[i - 1][2] || 0.0
+          elev2 = points[i][2] || 0.0
+          gain = elev2 - elev1
+          gain > 0 ? gain : 0.0
+        end
+      end
+
+      def moving_time_from_points(points, threshold_s: 30)
+        return 0 if points.length < 2
+        total = 0
+        (1...points.length).each do |i|
+          t1 = points[i - 1][3]
+          t2 = points[i][3]
+          next unless t1 && t2
+          diff = (t2 - t1).abs
+          total += diff if diff <= threshold_s
+        end
+        total.round
+      end
+
+      def elapsed_time_from_points(points)
+        return 0 if points.length < 2
+        times = points.map { |p| p[3] }.compact
+        return 0 if times.length < 2
+        ((times.last - times.first).abs).round
+      end
+
+      def build_run_id(source_prefix, value)
+        "#{source_prefix}_#{value}"
+      end
+
+      def default_sport
+        "other"
+      end
+
+      def simplify_polyline(points, max_points: 500)
+        return GitFit::Geo::Polyline.encode(points) if points.length <= max_points
+        step = (points.length.to_f / max_points).ceil
+        sampled = (0...points.length).step(step).map { |i| points[i] }
+        sampled << points.last if sampled.last != points.last
+        GitFit::Geo::Polyline.encode(sampled)
+      end
+
+      def normalize_sport_type(type)
+        return default_sport if type.nil? || type.empty?
+        mapping = {
+          "running" => "run", "run" => "run",
+          "cycling" => "ride", "biking" => "ride", "ride" => "ride",
+          "hiking" => "hike", "hike" => "hike",
+          "walking" => "walk", "walk" => "walk",
+          "swimming" => "swim", "swim" => "swim",
+          "skiing" => "ski", "ski" => "ski",
+          "workout" => "workout", "other" => "other"
+        }
+        mapping[type.downcase.strip] || default_sport
+      end
+
+      def build_activity_attrs(data)
+        {
+          run_id: data[:run_id],
+          name: data[:name],
+          distance: data[:distance]&.round(2),
+          moving_time: data[:moving_time]&.round,
+          elapsed_time: data[:elapsed_time]&.round,
+          sport_category: data[:sport_category] || default_sport,
+          sport_type: data[:sport_type],
+          start_date: format_time(data[:start_date]),
+          start_date_local: format_time_local(data[:start_date_local]),
+          location_country: data[:location_country],
+          summary_polyline: data[:summary_polyline],
+          average_heartrate: data[:average_heartrate]&.round(1),
+          average_speed: data[:distance] && data[:moving_time].to_f.positive? ? (data[:distance].to_f / data[:moving_time]).round(2) : data[:average_speed],
+          elevation_gain: data[:elevation_gain]&.round(1),
+          source: @source_name || data[:source]
+        }
+      end
+
+      def format_time(t)
+        return nil unless t
+        t.respond_to?(:iso8601) ? t.getutc.iso8601 : t.to_s
+      end
+
+      def format_time_local(t)
+        return nil unless t
+        t.respond_to?(:iso8601) ? t.iso8601 : t.to_s
+      end
+    end
+  end
+end

data/lib/git_fit/parser/fit.rb

@@ -0,0 +1,69 @@
+require "json"
+require "securerandom"
+require "time"
+
+module GitFit
+  module Parser
+    class FIT < Base
+      FIT_EPOCH = Time.utc(1989, 12, 31).freeze
+
+      def call(input)
+        path = input.is_a?(String) ? input : nil
+        return [] unless path && File.exist?(path)
+
+        records = GitFit::FIT::Decoder.decode(path)
+        return [] if records.empty?
+
+        points = records.filter_map { |r| record_to_point(r) }
+        return [] if points.empty?
+
+        times = points.map { |p| p[3] }.compact
+        start_date = times.min
+        end_date = times.max
+
+        sport_type = GitFit::FIT::Decoder.sport(path)
+
+        [build_activity_attrs({
+          run_id: build_run_id("fit", SecureRandom.hex(8)),
+          name: nil,
+          distance: total_distance(points),
+          moving_time: moving_time_from_points(points),
+          elapsed_time: elapsed_time_from_points(points),
+          sport_category: normalize_sport_type(sport_type),
+          sport_type: sport_type,
+          start_date: start_date,
+          start_date_local: start_date,
+          location_country: nil,
+          summary_polyline: simplify_polyline(points.map { |p| [p[0], p[1]] }),
+          average_heartrate: average_heartrate(points),
+          elevation_gain: elevation_gain(points),
+          source: "fit"
+        })]
+      end
+
+      private
+
+      def record_to_point(rec)
+        lat = rec["positionLat"]
+        lon = rec["positionLong"]
+        return nil unless lat && lon
+        ts = rec["timestamp"]
+        time = ts.is_a?(Numeric) ? FIT_EPOCH + ts : parse_time(ts)
+        [lat, lon, rec["altitude"], time, rec["heartRate"]]
+      end
+
+      def average_heartrate(points)
+        hrs = points.map { |p| p[4] }.compact
+        return nil if hrs.empty?
+        hrs.sum / hrs.size
+      end
+
+      def parse_time(str)
+        return nil unless str
+        Time.parse(str.to_s)
+      rescue ArgumentError
+        nil
+      end
+    end
+  end
+end

data/lib/git_fit/parser/gpx.rb

@@ -0,0 +1,80 @@
+require "time"
+require "nokogiri"
+
+module GitFit
+  module Parser
+    class GPX < Base
+      NS = { gpx: "http://www.topografix.com/GPX/1/1" }.freeze
+
+      def call(input)
+        doc = input.is_a?(String) ? Nokogiri::XML(input) : input
+        doc.remove_namespaces!
+        tracks = doc.xpath("//trk")
+        return [] if tracks.empty?
+        tracks.filter_map { |trk| parse_track(trk) }
+      end
+
+      private
+
+      def parse_track(trk)
+        name = trk.at_xpath("name")&.text
+        segments = trk.xpath("trkseg")
+        return nil if segments.empty?
+        points = segments.flat_map { |seg| parse_segment(seg) }
+        return nil if points.empty?
+        times = points.map { |p| p[3] }.compact
+        start_date = times.min
+        end_date = times.max
+        data = {
+          run_id: build_run_id("gpx", start_date&.strftime("%Y%m%dT%H%M%S") || SecureRandom.hex(4)),
+          name: name,
+          distance: total_distance(points),
+          moving_time: moving_time_from_points(points),
+          elapsed_time: elapsed_time_from_points(points),
+          sport_category: default_sport,
+          sport_type: nil,
+          start_date: start_date,
+          start_date_local: start_date,
+          location_country: nil,
+          summary_polyline: simplify_polyline(points.map { |p| [p[0], p[1]] }),
+          average_heartrate: average_heartrate(points),
+          elevation_gain: elevation_gain(points),
+          source: "gpx"
+        }
+        build_activity_attrs(data)
+      end
+
+      def parse_segment(seg)
+        seg.xpath("trkpt").filter_map do |pt|
+          lat = pt["lat"]&.to_f
+          lon = pt["lon"]&.to_f
+          next unless lat && lon
+          elev = pt.at_xpath("ele")&.text&.to_f
+          time = parse_time(pt.at_xpath("time")&.text)
+          hr = parse_heartrate(pt)
+          [lat, lon, elev, time, hr]
+        end
+      end
+
+      def parse_heartrate(pt)
+        ext = pt.at_xpath("extensions")
+        return nil unless ext
+        hr = ext.at_xpath(".//hr")
+        hr&.text&.to_f
+      end
+
+      def average_heartrate(points)
+        hrs = points.map { |p| p[4] }.compact
+        return nil if hrs.empty?
+        hrs.sum / hrs.size
+      end
+
+      def parse_time(str)
+        return nil unless str
+        Time.parse(str)
+      rescue ArgumentError
+        nil
+      end
+    end
+  end
+end

data/lib/git_fit/parser/tcx.rb

@@ -0,0 +1,89 @@
+require "time"
+require "nokogiri"
+
+module GitFit
+  module Parser
+    class TCX < Base
+      NS = { tcx: "http://www.garmin.com/xmlschemas/TrainingCenterDatabase/v2" }.freeze
+
+      def call(input)
+        doc = input.is_a?(String) ? Nokogiri::XML(input) : input
+        activities = doc.xpath("//tcx:Activities/tcx:Activity", NS)
+        return [] if activities.empty?
+        activities.filter_map { |act| parse_activity(act) }
+      end
+
+      private
+
+      def parse_activity(act)
+        sport = act["Sport"]
+        laps = act.xpath("tcx:Lap", NS)
+        return nil if laps.empty?
+        lap_data = laps.map { |lap| parse_lap(lap) }.compact
+        return nil if lap_data.empty?
+        total_distance = lap_data.sum { |ld| ld[:distance] || 0.0 }
+        total_moving_time = lap_data.sum { |ld| ld[:moving_time] || 0 }
+        total_elapsed_time = lap_data.sum { |ld| ld[:elapsed_time] || 0 }
+        elevation_gain = lap_data.sum { |ld| ld[:elevation_gain] || 0.0 }
+        avg_hr = lap_data.map { |ld| ld[:avg_hr] }.compact
+        all_points = lap_data.flat_map { |ld| ld[:points] }
+        times = all_points.map { |p| p[3] }.compact
+        start_date = times.min
+        data = {
+          run_id: build_run_id("tcx", start_date&.strftime("%Y%m%dT%H%M%S") || SecureRandom.hex(4)),
+          name: act.at_xpath("tcx:Notes", NS)&.text,
+          distance: total_distance,
+          moving_time: total_moving_time,
+          elapsed_time: total_elapsed_time,
+          sport_category: normalize_sport_type(sport),
+          sport_type: sport,
+          start_date: start_date,
+          start_date_local: start_date,
+          location_country: nil,
+          summary_polyline: simplify_polyline(all_points.map { |p| [p[0], p[1]] }),
+          average_heartrate: avg_hr.empty? ? nil : (avg_hr.sum / avg_hr.size).round(1),
+          elevation_gain: elevation_gain,
+          source: "tcx"
+        }
+        build_activity_attrs(data)
+      end
+
+      def parse_lap(lap)
+        points = parse_track(lap)
+        return nil if points.empty?
+        distance = lap.at_xpath("tcx:DistanceMeters", NS)&.text&.to_f
+        total_time = lap.at_xpath("tcx:TotalTimeSeconds", NS)&.text&.to_f
+        avg_hr_node = lap.at_xpath("tcx:AverageHeartRateBpm/tcx:Value", NS)
+        avg_hr = avg_hr_node&.text&.to_f
+        elev_gain = points.length >= 2 ? elevation_gain(points) : 0.0
+        moving_time = moving_time_from_points(points, threshold_s: 30)
+        { distance: distance, elapsed_time: total_time&.round,
+          moving_time: moving_time > 0 ? moving_time : (total_time&.round || 0),
+          avg_hr: avg_hr, elevation_gain: elev_gain, points: points }
+      end
+
+      def parse_track(lap)
+        track = lap.at_xpath("tcx:Track", NS)
+        return [] unless track
+        track.xpath("tcx:Trackpoint", NS).filter_map do |tp|
+          pos = tp.at_xpath("tcx:Position", NS)
+          next unless pos
+          lat = pos.at_xpath("tcx:LatitudeDegrees", NS)&.text&.to_f
+          lon = pos.at_xpath("tcx:LongitudeDegrees", NS)&.text&.to_f
+          next unless lat && lon
+          elev = tp.at_xpath("tcx:AltitudeMeters", NS)&.text&.to_f
+          time = parse_time(tp.at_xpath("tcx:Time", NS)&.text)
+          hr = tp.at_xpath("tcx:HeartRateBpm/tcx:Value", NS)&.text&.to_f
+          [lat, lon, elev, time, hr]
+        end
+      end
+
+      def parse_time(str)
+        return nil unless str
+        Time.parse(str)
+      rescue ArgumentError
+        nil
+      end
+    end
+  end
+end

data/lib/git_fit/parser.rb

@@ -0,0 +1,9 @@
+module GitFit
+  module Parser
+  end
+end
+
+require_relative "parser/base"
+require_relative "parser/gpx"
+require_relative "parser/tcx"
+require_relative "parser/fit"

data/lib/git_fit/privacy/polyline_filter.rb

@@ -0,0 +1,79 @@
+module GitFit
+  module Privacy
+    class PolylineFilter
+      def initialize(config: {})
+        @start_end_range = (config["start_end_range"] || 200).to_f / 1000.0
+        @ignore_polyline = decode_polyline(config["polyline"]) if config["polyline"]
+        @ignore_range = (config["range"] || 0).to_f / 1000.0
+        @before_saving = config["before_saving"] || false
+      end
+
+      def before_saving?
+        @before_saving
+      end
+
+      def filter(polyline_str)
+        return nil if polyline_str.nil? || polyline_str.empty?
+        points = decode_polyline(polyline_str)
+        return polyline_str if points.nil? || points.empty?
+        points = filter_start_end(points)
+        points = filter_range(points)
+        return nil if points.empty?
+        encode_polyline(points)
+      end
+
+      private
+
+      def filter_start_end(points)
+        return points if @start_end_range <= 0
+        start_idx = 0
+        dist = 0.0
+        (1...points.length).each do |i|
+          dist += haversine(points[i], points[i - 1])
+          start_idx = i
+          break if dist > @start_end_range
+        end
+        end_idx = points.length - 1
+        dist = 0.0
+        (points.length - 2).downto(0) do |i|
+          dist += haversine(points[i], points[i + 1])
+          end_idx = i
+          break if dist > @start_end_range
+        end
+        return [] if start_idx >= end_idx
+        points[start_idx..end_idx]
+      end
+
+      def filter_range(points)
+        return points if @ignore_polyline.nil? || @ignore_range <= 0
+        points.reject do |point|
+          @ignore_polyline.any? { |ip| haversine(point, ip) < @ignore_range }
+        end
+      end
+
+      def haversine(p1, p2)
+        lat1 = deg_to_rad(p1[0])
+        lat2 = deg_to_rad(p2[0])
+        dlat = deg_to_rad(p2[0] - p1[0])
+        dlon = deg_to_rad(p2[1] - p1[1])
+        a = Math.sin(dlat / 2) ** 2 +
+            Math.cos(lat1) * Math.cos(lat2) *
+            Math.sin(dlon / 2) ** 2
+        c = 2 * Math.atan2(Math.sqrt(a), Math.sqrt(1 - a))
+        6371.0 * c
+      end
+
+      def deg_to_rad(deg)
+        deg * Math::PI / 180.0
+      end
+
+      def decode_polyline(str)
+        GitFit::Geo::Polyline.decode(str)
+      end
+
+      def encode_polyline(points)
+        GitFit::Geo::Polyline.encode(points)
+      end
+    end
+  end
+end

data/lib/git_fit/sport_mapper.rb

@@ -0,0 +1,80 @@
+module GitFit
+  module SportMapper
+    ALIASES = {
+      "running" => "run", "trailrun" => "run", "trail_run" => "run",
+      "virtualrun" => "run", "virtual_run" => "run",
+      "indoorrun" => "run", "indoor_run" => "run",
+      "cycling" => "ride", "biking" => "ride",
+      "mountainbike" => "ride", "gravelride" => "ride", "ebikeride" => "ride",
+      "virtualride" => "ride", "virtual_ride" => "ride",
+      "indoor_ride" => "ride", "indoorride" => "ride",
+      "hiking" => "hike",
+      "walking" => "walk",
+      "swimming" => "swim",
+      "skiing" => "ski", "backcountryski" => "ski", "nordicski" => "ski",
+      "strengthtraining" => "workout"
+    }.freeze
+
+    KEYWORDS = [
+      [/\b(?:run|jog|sprint|marathon)\w*\b/i, "run"],
+      [/\b(?:ride|cycl|bike|mountain\.?bike|gravel|ebike)\w*\b/i, "ride"],
+      [/\b(?:hike|climb|mountaineer|trek)\w*\b/i, "hike"],
+      [/\b(?:walk|stroll)\w*\b/i, "walk"],
+      [/\b(?:swim|pool|laps?)\w*\b/i, "swim"],
+      [/\b(?:ski|snowboard|nordic)\w*\b/i, "ski"],
+      [/\b(?:workout|train|gym|fitness|yoga|pilates|crossfit|elliptical|strength)\w*\b/i, "workout"]
+    ].freeze
+
+    LEV_REFERENCES = %w[
+      running run trailrun trail_run virtualrun virtual_run indoorrun indoor_run
+      cycling ride biking mountainbike gravelride ebikeride
+      virtualride virtual_ride indoor_ride indoorride
+      hiking hike walking walk swimming swim skiing ski
+      workout strengthtraining training elliptical cardio functional
+    ].freeze
+
+    LEV_THRESHOLD = 3
+
+    def self.canonicalize(str)
+      return "other" if str.nil? || str.empty?
+      key = str.to_s.downcase.strip
+      return ALIASES[key] if ALIASES.key?(key)
+      KEYWORDS.each { |regex, sport| return sport if regex.match?(str) }
+      best = lev_match(key)
+      return best if best
+      "other"
+    end
+
+    def self.lev_match(str)
+      best = nil
+      best_dist = Float::INFINITY
+      LEV_REFERENCES.each do |ref|
+        dist = levenshtein(str, ref)
+        if dist < best_dist
+          best_dist = dist
+          best = ref
+        end
+      end
+      return nil if best_dist > LEV_THRESHOLD
+      ALIASES[best] || best
+    end
+
+    def self.levenshtein(a, b)
+      n, m = a.length, b.length
+      return m if n == 0
+      return n if m == 0
+      cur = (0..m).to_a
+      (1..n).each do |i|
+        prev = cur[0]
+        cur[0] = i
+        (1..m).each do |j|
+          tmp = cur[j]
+          cost = a[i - 1] == b[j - 1] ? 0 : 1
+          cur[j] = [cur[j] + 1, cur[j - 1] + 1, prev + cost].min
+          prev = tmp
+        end
+      end
+      cur[m]
+    end
+  end
+end

data/lib/git_fit/timezone/resolver.rb

@@ -0,0 +1,20 @@
+require "timezone_finder"
+
+module GitFit
+  module Timezone
+    class Resolver
+      def initialize(config, finder: nil)
+        default = config.is_a?(Hash) ? config.dig("system", "timezone") : config
+        @finder = finder || TimezoneFinder.create
+        @default = default || "Asia/Shanghai"
+      end
+
+      def resolve(lat, lng)
+        return @default unless lat && lng
+        tz = @finder.timezone_at(lat: lat.to_f, lng: lng.to_f)
+        tz = nil if tz.is_a?(String) && tz.empty?
+        tz || @default
+      end
+    end
+  end
+end

data/lib/git_fit/version.rb

@@ -1,3 +1,3 @@
 module GitFit
-  VERSION = "0.1.1"
+  VERSION = "0.3.2"
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: git-fit
 version: !ruby/object:Gem::Version
-  version: 0.1.1
+  version: 0.3.2
 platform: ruby
 authors:
 - Lax
@@ -23,6 +23,76 @@ dependencies:
     - - "~>"
       - !ruby/object:Gem::Version
         version: '1.3'
+- !ruby/object:Gem::Dependency
+  name: sequel
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '5.0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '5.0'
+- !ruby/object:Gem::Dependency
+  name: sqlite3
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.0'
+- !ruby/object:Gem::Dependency
+  name: nokogiri
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.16'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.16'
+- !ruby/object:Gem::Dependency
+  name: mini_racer
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.12'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.12'
+- !ruby/object:Gem::Dependency
+  name: timezone_finder
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.5'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.5'
 description: A git extension CLI for aggregating, managing, and exporting fitness
   activity data from multiple sources (Garmin, Strava, Keep, etc.)
 email:
@@ -37,8 +107,24 @@ files:
 - lib/git_fit/cli.rb
 - lib/git_fit/config.rb
 - lib/git_fit/config_template.rb
+- lib/git_fit/db/activity.rb
+- lib/git_fit/db/cli.rb
+- lib/git_fit/db/connection.rb
+- lib/git_fit/fit.rb
+- lib/git_fit/fit/decoder.rb
+- lib/git_fit/geo.rb
+- lib/git_fit/geo/coord_transform.rb
+- lib/git_fit/geo/polyline.rb
+- lib/git_fit/parser.rb
+- lib/git_fit/parser/base.rb
+- lib/git_fit/parser/fit.rb
+- lib/git_fit/parser/gpx.rb
+- lib/git_fit/parser/tcx.rb
+- lib/git_fit/privacy/polyline_filter.rb
+- lib/git_fit/sport_mapper.rb
 - lib/git_fit/sync/base.rb
 - lib/git_fit/sync/strava.rb
+- lib/git_fit/timezone/resolver.rb
 - lib/git_fit/version.rb
 homepage: https://github.com/Lax/git-fit
 licenses: