From db4d2b40895db41ce188549f49a6f277ba95c890 Mon Sep 17 00:00:00 2001 From: Martin Kagamino Lehoux Date: Sun, 6 Sep 2026 16:40:17 +0200 Subject: Split cli.go into per-domain command files Move each CLI command into its owning package (mountain_pass, ride, web) with dispatch and usage in main.go; remove the cli package. --- cli/cli.go | 568 --------------------------------------------------- cli/cli_test.go | 55 ----- main.go | 64 +++++- mountain_pass/cli.go | 39 ++++ ride/cli.go | 481 +++++++++++++++++++++++++++++++++++++++++++ ride/cli_test.go | 54 +++++ web/cli.go | 18 ++ 7 files changed, 654 insertions(+), 625 deletions(-) delete mode 100644 cli/cli.go delete mode 100644 cli/cli_test.go create mode 100644 mountain_pass/cli.go create mode 100644 ride/cli.go create mode 100644 ride/cli_test.go create mode 100644 web/cli.go diff --git a/cli/cli.go b/cli/cli.go deleted file mode 100644 index 66ebb98..0000000 --- a/cli/cli.go +++ /dev/null @@ -1,568 +0,0 @@ -package cli - -import ( - "context" - "database/sql" - "encoding/json" - "errors" - "fmt" - "log/slog" - "math" - "os" - "sort" - "strconv" - "strings" - "text/tabwriter" - "time" - - "github.com/martinlehoux/biking_home/climb" - "github.com/martinlehoux/biking_home/config" - "github.com/martinlehoux/biking_home/mountain_pass" - "github.com/martinlehoux/biking_home/ride" - "github.com/martinlehoux/biking_home/web" - "github.com/martinlehoux/kagamigo/kcore" - "github.com/schollz/progressbar/v3" -) - -func Run(db *sql.DB, configPath string, appConfig config.Config, args []string, enablePprof bool) { - if len(args) == 0 { - runServer(db, configPath, appConfig, enablePprof) - return - } - - switch args[0] { - case "fetch-osm": - err := mountain_pass.FetchFrancePBF("france-latest.osm.pbf") - kcore.Expect(err, "failed to download France OSM PBF") - case "extract-osm": - if len(args) < 2 { - fmt.Fprintln(os.Stderr, "extract-osm requires a PBF file path argument") - printUsage() - os.Exit(2) - } - pbfPath := args[1] - enabled := progressBarEnabled() - var bar *progressbar.ProgressBar - _, err := mountain_pass.ExtractMountainPasses(context.Background(), pbfPath, db, func(current, total int64) { - if bar == nil && enabled { - bar = progressbar.DefaultBytes(total, "Extracting mountain passes") - } - if bar != nil { - bar.Set64(current) - } - }) - if bar != nil { - bar.Finish() - } - kcore.Expect(err, "failed to extract mountain passes from OSM") - case "backfill": - enabled := progressBarEnabled() - var bar *progressbar.ProgressBar - count, err := ride.Backfill(db, func(current, total int) { - if bar == nil && enabled { - bar = progressbar.Default(int64(total), "Backfilling ride values") - } - if bar != nil { - bar.Set(current) - } - }) - if bar != nil { - bar.Finish() - } - kcore.Expect(err, "failed to backfill ride values") - slog.Info("Backfilled ride values", "rides", count) - case "backtest": - kcore.Expect(runBacktest(db), "failed to run backtest") - case "elevation": - if len(args) < 2 { - fmt.Fprintln(os.Stderr, "elevation requires subcommand: analyse | fix") - printElevationUsage() - os.Exit(2) - } - switch args[1] { - case "analyse", "analyze": - kcore.Expect(runElevationAnalyse(db, args[2:]), "elevation analyse failed") - case "fix": - kcore.Expect(runElevationFix(db, args[2:]), "elevation fix failed") - default: - fmt.Fprintf(os.Stderr, "unknown elevation subcommand %q\n", args[1]) - printElevationUsage() - os.Exit(2) - } - case "serve": - pprof := enablePprof - for _, arg := range args[1:] { - if arg == "--pprof" || arg == "-pprof" || arg == "pprof" { - pprof = true - } - } - runServer(db, configPath, appConfig, pprof) - case "help", "-h", "--help": - printUsage() - default: - fmt.Fprintf(os.Stderr, "unknown command %q\n", args[0]) - printUsage() - os.Exit(2) - } -} - -func printUsage() { - fmt.Fprintf(os.Stderr, `Usage: biking_home [global flags] [args] - -Global flags: - -config path to YAML configuration file (default "config.yaml") - -pprof expose pprof endpoints at /debug/pprof (also: "serve --pprof") - -Commands: - serve start web server (default when no command given) - fetch-osm download the France OSM PBF into france-latest.osm.pbf - extract-osm extract mountain passes from an OSM PBF file - backfill recompute all stored ride values - backtest run data benchmarks comparing computed values against stored reference values - elevation analyse detect elevation outliers (tunnel spikes) - elevation fix linearly fix elevation between anchors -`) -} - -// progressBarEnabled reports whether stderr is attached to a terminal, so the -// progress bar only renders for interactive runs and stays out of piped or -// redirected output. -func progressBarEnabled() bool { - fi, err := os.Stderr.Stat() - return err == nil && fi.Mode()&os.ModeCharDevice != 0 -} - -func runServer(db *sql.DB, configPath string, appConfig config.Config, enablePprof bool) { - server := web.NewServer(db, configPath).WithPprof(enablePprof) - if enablePprof { - slog.Info("pprof enabled", "endpoint", appConfig.Server.PublicURL+"/debug/pprof/") - } - slog.Info("Starting web server", "address", appConfig.Server.PublicURL) - kcore.Expect(server.ListenAndServe(appConfig.Server.Address), "web server stopped") -} - -type backtestSample struct { - externalID string - name string - computed time.Duration - reference time.Duration - relErrorPct float64 -} - -func runBacktest(db *sql.DB) error { - items, err := ride.List(db) - if err != nil { - return err - } - var samples []backtestSample - var bar *progressbar.ProgressBar - if progressBarEnabled() { - bar = progressbar.Default(int64(len(items)), "Backtesting rides") - defer bar.Finish() - } - for _, item := range items { - if bar != nil { - bar.Add(1) - } - if !isBacktestEligible(item) { - continue - } - parsed, err := ride.ParseFile(ride.FITRideParser{}, item.FitPath) - if err != nil { - if errors.Is(err, ride.ErrNoTrackPoints) { - continue - } - slog.Warn("Failed to parse ride FIT", "ride", item.ExternalID, "file", item.FitPath, "error", err) - continue - } - reference := time.Duration(item.ExternalMovingTimeS) * time.Second - computed := ride.MovingTime(parsed) - samples = append(samples, backtestSample{ - externalID: item.ExternalID, - name: item.Name, - computed: computed, - reference: reference, - relErrorPct: (float64(computed) - float64(reference)) / float64(reference) * 100, - }) - } - if len(samples) == 0 { - slog.Info("No rides with FIT to backtest", "rides", len(items)) - return nil - } - sort.Slice(samples, func(i, j int) bool { - return math.Abs(samples[i].relErrorPct) > math.Abs(samples[j].relErrorPct) - }) - w := tabwriter.NewWriter(os.Stdout, 0, 0, 2, ' ', 0) - fmt.Fprintln(w, "computed\treference\terr %\tride") - limit := min(len(samples), 10) - for _, s := range samples[:limit] { - fmt.Fprintf(w, "%s\t%s\t%+.1f\t%s (%s)\n", s.computed.Round(time.Second), s.reference.Round(time.Second), s.relErrorPct, s.name, s.externalID) - } - w.Flush() - - absErrors := make([]float64, 0, len(samples)) - for _, s := range samples { - absErrors = append(absErrors, math.Abs(s.relErrorPct)) - } - percentiles := []float64{50, 75, 90, 95, 99} - distribution := errorDistribution(absErrors, percentiles) - table := tabwriter.NewWriter(os.Stdout, 0, 0, 2, ' ', 0) - fmt.Fprintln(table, "percentile\tabs err %") - for _, p := range percentiles { - fmt.Fprintf(table, "p%g\t%.1f\n", p, distribution[p]) - } - table.Flush() - slog.Info("Moving time backtest", "rides", len(samples), "mean_err_pct", math.Round(meanAbsErr(absErrors)*10)/10, "stderr_pct", math.Round(stdErrAbsErr(absErrors)*10)/10) - return nil -} - -func isBacktestEligible(item ride.StoredRide) bool { - if item.FitPath == "" || item.ExternalMovingTimeS <= 0 || item.ElapsedTimeS <= 0 { - return false - } - if !item.IsCategorised() { - return false - } - if item.RideType == ride.RideTypeIndoor || item.RideType == ride.RideTypeTransport { - return false - } - return true -} - -func meanAbsErr(absErrors []float64) float64 { - var sum float64 - for _, err := range absErrors { - sum += err - } - return sum / float64(len(absErrors)) -} - -func stdErrAbsErr(absErrors []float64) float64 { - mean := meanAbsErr(absErrors) - var sumSquares float64 - for _, err := range absErrors { - sumSquares += (err - mean) * (err - mean) - } - variance := sumSquares / float64(len(absErrors)-1) - return math.Sqrt(variance / float64(len(absErrors))) -} - -func errorDistribution(absErrors []float64, percentiles []float64) map[float64]float64 { - sorted := append([]float64(nil), absErrors...) - sort.Float64s(sorted) - distribution := map[float64]float64{} - for _, p := range percentiles { - index := max(int(math.Ceil(p/100*float64(len(sorted)))-1), 0) - if index >= len(sorted) { - index = len(sorted) - 1 - } - distribution[p] = sorted[index] - } - return distribution -} - -func printElevationUsage() { - fmt.Fprintf(os.Stderr, `Usage: - biking_home elevation analyse [--json] [--threshold ] - biking_home elevation fix --auto [--threshold ] [--dry-run] - biking_home elevation fix --from --to [--dry-run] - -Examples: - biking_home elevation analyse 754 - biking_home elevation analyse all --json | jq - biking_home elevation fix 754 --auto - biking_home elevation fix 754 --from 4.4km --to 4.8km - biking_home elevation fix 754 --from 927 --to 992 -`) -} - -type elevationAnalyseResult struct { - RideID int64 `json:"rideId"` - Name string `json:"name"` - Distance float64 `json:"distanceM"` - Cotacol float64 `json:"cotacol"` - Zones []ride.FixZone `json:"zones"` -} - -func runElevationAnalyse(db *sql.DB, args []string) error { - var target string - var jsonOut bool - var threshold float64 = ride.DefaultGradeThreshold - for i := 0; i < len(args); i++ { - switch args[i] { - case "--json": - jsonOut = true - case "--threshold": - if i+1 >= len(args) { - return errors.New("--threshold requires a value") - } - i++ - v, err := strconv.ParseFloat(args[i], 64) - if err != nil { - return fmt.Errorf("invalid threshold %q: %w", args[i], err) - } - threshold = v - default: - if strings.HasPrefix(args[i], "--") { - return fmt.Errorf("unknown flag %q", args[i]) - } - if target == "" { - target = args[i] - } else { - return fmt.Errorf("unexpected arg %q", args[i]) - } - } - } - if target == "" { - return errors.New("elevation analyse requires ") - } - var rides []ride.StoredRide - if target == "all" { - all, err := ride.List(db) - if err != nil { - return err - } - rides = all - } else { - id, err := strconv.ParseInt(target, 10, 64) - if err != nil { - return fmt.Errorf("invalid ride id %q", target) - } - item, found, err := ride.GetByID(db, id) - if err != nil { - return err - } - if !found { - return fmt.Errorf("ride %d not found", id) - } - rides = []ride.StoredRide{item} - } - results := make([]elevationAnalyseResult, 0, len(rides)) - for _, item := range rides { - if item.FitPath == "" && item.GPXPath == "" { - continue - } - var parsed ride.Ride - var err error - if item.FitPath != "" { - parsed, err = ride.ParseFile(ride.FITRideParser{}, item.FitPath) - if err != nil && item.GPXPath != "" { - parsed, err = ride.ParseFile(ride.GPXRideParser{}, item.GPXPath) - } - } else { - parsed, err = ride.ParseFile(ride.GPXRideParser{}, item.GPXPath) - } - if err != nil { - slog.Warn("Failed to parse ride for elevation analyse", "ride", item.ID, "error", err) - continue - } - outliers := ride.DetectElevationOutliers(parsed.Distances, parsed.Elevations, threshold) - if len(outliers) == 0 && target != "all" { - // still report empty - } else if len(outliers) == 0 { - continue - } - zones := ride.SuggestFixZones(outliers) - cotacol := parsed.Cotacol() - results = append(results, elevationAnalyseResult{ - RideID: item.ID, - Name: item.Name, - Distance: item.DistanceM, - Cotacol: cotacol, - Zones: zones, - }) - } - if target == "all" { - sort.Slice(results, func(i, j int) bool { - maxI, maxJ := 0.0, 0.0 - for _, z := range results[i].Zones { - // parse reason grade not stored; use zone span as proxy - span := z.EndKm - z.StartKm - if span > maxI { - maxI = span - } - } - for _, z := range results[j].Zones { - span := z.EndKm - z.StartKm - if span > maxJ { - maxJ = span - } - } - return len(results[i].Zones) > len(results[j].Zones) || (len(results[i].Zones) == len(results[j].Zones) && maxI > maxJ) - }) - } - if jsonOut { - enc := json.NewEncoder(os.Stdout) - enc.SetIndent("", " ") - return enc.Encode(results) - } - if len(results) == 0 { - fmt.Println("No elevation outliers detected.") - return nil - } - w := tabwriter.NewWriter(os.Stdout, 0, 0, 2, ' ', 0) - fmt.Fprintln(w, "ride\tname\tcotacol\tzone\tkm\tgrade") - for _, r := range results { - for _, z := range r.Zones { - fmt.Fprintf(w, "%d\t%s\t%.1f\t%d→%d\t%.2f–%.2f\t%s\n", r.RideID, r.Name, r.Cotacol, z.StartIdx, z.EndIdx, z.StartKm, z.EndKm, z.Reason) - } - } - w.Flush() - slog.Info("Elevation analyse complete", "rides", len(results)) - return nil -} - -func runElevationFix(db *sql.DB, args []string) error { - var rideIDRaw string - var fromRaw, toRaw string - var auto bool - var dryRun bool - var threshold float64 = ride.DefaultGradeThreshold - for i := 0; i < len(args); i++ { - switch args[i] { - case "--auto": - auto = true - case "--dry-run": - dryRun = true - case "--from": - if i+1 >= len(args) { - return errors.New("--from requires a value") - } - i++ - fromRaw = args[i] - case "--to": - if i+1 >= len(args) { - return errors.New("--to requires a value") - } - i++ - toRaw = args[i] - case "--threshold": - if i+1 >= len(args) { - return errors.New("--threshold requires a value") - } - i++ - v, err := strconv.ParseFloat(args[i], 64) - if err != nil { - return fmt.Errorf("invalid threshold %q: %w", args[i], err) - } - threshold = v - default: - if strings.HasPrefix(args[i], "--") { - return fmt.Errorf("unknown flag %q", args[i]) - } - if rideIDRaw == "" { - rideIDRaw = args[i] - } else { - return fmt.Errorf("unexpected arg %q", args[i]) - } - } - } - if rideIDRaw == "" { - return errors.New("elevation fix requires ") - } - if !auto && (fromRaw == "" || toRaw == "") { - return errors.New("elevation fix requires --auto or --from/--to") - } - if auto && (fromRaw != "" || toRaw != "") { - return errors.New("--auto cannot be combined with --from/--to") - } - id, err := strconv.ParseInt(rideIDRaw, 10, 64) - if err != nil { - return fmt.Errorf("invalid ride id %q", rideIDRaw) - } - item, found, err := ride.GetByID(db, id) - if err != nil { - return err - } - if !found { - return fmt.Errorf("ride %d not found", id) - } - if item.FitPath == "" && item.GPXPath == "" { - return fmt.Errorf("ride %d has no route files", id) - } - var parsed ride.Ride - if item.FitPath != "" { - parsed, err = ride.ParseFile(ride.FITRideParser{}, item.FitPath) - if err != nil && item.GPXPath != "" { - parsed, err = ride.ParseFile(ride.GPXRideParser{}, item.GPXPath) - } - } else { - parsed, err = ride.ParseFile(ride.GPXRideParser{}, item.GPXPath) - } - if err != nil { - return fmt.Errorf("parse ride %d: %w", id, err) - } - before := parsed.Cotacol() - var zones []ride.FixZone - if auto { - outliers := ride.DetectElevationOutliers(parsed.Distances, parsed.Elevations, threshold) - if len(outliers) == 0 { - fmt.Printf("Ride %d: no outliers detected (threshold %.0f%%)\n", id, threshold*100) - return nil - } - zones = ride.SuggestFixZones(outliers) - } else { - fromIdx, err := ride.ResolveIndex(parsed.Distances, fromRaw) - if err != nil { - return fmt.Errorf("invalid --from: %w", err) - } - toIdx, err := ride.ResolveIndex(parsed.Distances, toRaw) - if err != nil { - return fmt.Errorf("invalid --to: %w", err) - } - if fromIdx >= toIdx { - return errors.New("--from must be before --to") - } - zones = []ride.FixZone{{ - StartIdx: fromIdx, - EndIdx: toIdx, - StartKm: parsed.Distances[fromIdx] / 1000, - EndKm: parsed.Distances[toIdx] / 1000, - Reason: "manual", - }} - } - if dryRun { - fmt.Printf("Ride %d %q: would fix %d zone(s), cotacol %.1f -> preview\n", id, item.Name, len(zones), before) - for _, z := range zones { - fmt.Printf(" %d→%d %.3f–%.3f km %s\n", z.StartIdx, z.EndIdx, z.StartKm, z.EndKm, z.Reason) - } - // Preview cotacol after fix - elevCopy := make([]float64, len(parsed.Elevations)) - copy(elevCopy, parsed.Elevations) - ride.LinearFix(parsed.Distances, elevCopy, zones) - afterPreview := climb.Cotacol(parsed.Distances, elevCopy) - fmt.Printf(" cotacol preview: %.1f -> %.1f (Δ %.1f)\n", before, afterPreview, afterPreview-before) - return nil - } - slog.Info("Fixing elevation", "ride", id, "zones", len(zones)) - if err := ride.FixRideFiles(parsed, zones, item.GPXPath, item.FitPath); err != nil { - return err - } - // Re-parse to compute new cotacol and persist via Save (recomputes stored values from files). - // Reload item to get potentially derived paths - updated := item - // If one path was missing, FixRideFiles may have created it; update derived path for Save - if updated.FitPath == "" && updated.GPXPath != "" { - updated.FitPath = updated.GPXPath[:len(updated.GPXPath)-4] + ".fit" - if _, err := os.Stat(updated.FitPath); err != nil { - updated.FitPath = "" - } - } - if err := ride.Save(db, updated); err != nil { - return fmt.Errorf("save ride %d: %w", id, err) - } - // Report - reparsed, _ := ride.ParseFile(ride.FITRideParser{}, updated.FitPath) - if reparsed.Len() == 0 && updated.GPXPath != "" { - reparsed, _ = ride.ParseFile(ride.GPXRideParser{}, updated.GPXPath) - } - after := 0.0 - if reparsed.Len() > 0 { - after = reparsed.Cotacol() - } - fmt.Printf("Ride %d %q fixed: %d zone(s), cotacol %.1f -> %.1f\n", id, item.Name, len(zones), before, after) - for _, z := range zones { - fmt.Printf(" %d→%d %.3f–%.3f km %s\n", z.StartIdx, z.EndIdx, z.StartKm, z.EndKm, z.Reason) - } - return nil -} diff --git a/cli/cli_test.go b/cli/cli_test.go deleted file mode 100644 index e12ff7a..0000000 --- a/cli/cli_test.go +++ /dev/null @@ -1,55 +0,0 @@ -package cli - -import ( - "testing" - - "github.com/martinlehoux/biking_home/ride" - "github.com/stretchr/testify/assert" -) - -func TestBacktestEligibilityExcludesShortDistances(t *testing.T) { - short := ride.StoredRide{FitPath: "ride.fit", DistanceM: 10_000 - 1, ExternalMovingTimeS: 8_000, ElapsedTimeS: 10_000, BikeType: ride.BikeTypeRoad, RideType: ride.RideTypeTraining} - minimum := ride.StoredRide{FitPath: "ride.fit", DistanceM: 10_000, ExternalMovingTimeS: 8_000, ElapsedTimeS: 10_000, BikeType: ride.BikeTypeRoad, RideType: ride.RideTypeTraining} - - assert.True(t, isBacktestEligible(short)) - assert.True(t, isBacktestEligible(minimum)) -} - -func TestBacktestEligibilityExcludesLowMovingRatio(t *testing.T) { - low := ride.StoredRide{FitPath: "ride.fit", DistanceM: 10_000, ExternalMovingTimeS: 7_999, ElapsedTimeS: 10_000, BikeType: ride.BikeTypeRoad, RideType: ride.RideTypeTraining} - boundary := ride.StoredRide{FitPath: "ride.fit", DistanceM: 10_000, ExternalMovingTimeS: 8_000, ElapsedTimeS: 10_000, BikeType: ride.BikeTypeRoad, RideType: ride.RideTypeTraining} - noElapsed := ride.StoredRide{FitPath: "ride.fit", DistanceM: 10_000, ExternalMovingTimeS: 1, BikeType: ride.BikeTypeRoad, RideType: ride.RideTypeTraining} - - assert.True(t, isBacktestEligible(low)) - assert.True(t, isBacktestEligible(boundary)) - assert.False(t, isBacktestEligible(noElapsed)) -} - -func TestBacktestEligibilityExcludesUncategorisedAndIndoorTransport(t *testing.T) { - base := ride.StoredRide{FitPath: "ride.fit", ExternalMovingTimeS: 8_000, ElapsedTimeS: 10_000, BikeType: ride.BikeTypeRoad, RideType: ride.RideTypeTraining} - uncategorised := ride.StoredRide{FitPath: "ride.fit", ExternalMovingTimeS: 8_000, ElapsedTimeS: 10_000} - indoor := ride.StoredRide{FitPath: "ride.fit", ExternalMovingTimeS: 8_000, ElapsedTimeS: 10_000, BikeType: ride.BikeTypeRoad, RideType: ride.RideTypeIndoor} - transport := ride.StoredRide{FitPath: "ride.fit", ExternalMovingTimeS: 8_000, ElapsedTimeS: 10_000, BikeType: ride.BikeTypeRoad, RideType: ride.RideTypeTransport} - race := ride.StoredRide{FitPath: "ride.fit", ExternalMovingTimeS: 8_000, ElapsedTimeS: 10_000, BikeType: ride.BikeTypeMTB, RideType: ride.RideTypeRace} - - assert.True(t, isBacktestEligible(base)) - assert.False(t, isBacktestEligible(uncategorised)) - assert.False(t, isBacktestEligible(indoor)) - assert.False(t, isBacktestEligible(transport)) - assert.True(t, isBacktestEligible(race)) -} - -func TestBacktestStatsUseUnroundedSamples(t *testing.T) { - absErrors := []float64{0, 0.1, 0.1} - - assert.InDelta(t, 1.0/15, meanAbsErr(absErrors), 1e-12) - assert.InDelta(t, 1.0/30, stdErrAbsErr(absErrors), 1e-12) -} - -func TestErrorDistributionUsesNearestRank(t *testing.T) { - distribution := errorDistribution([]float64{1, 2, 3, 4}, []float64{50, 75, 99}) - - assert.Equal(t, 2.0, distribution[50]) - assert.Equal(t, 3.0, distribution[75]) - assert.Equal(t, 4.0, distribution[99]) -} diff --git a/main.go b/main.go index 397b3d6..93bfcd6 100644 --- a/main.go +++ b/main.go @@ -3,11 +3,15 @@ package main import ( "database/sql" "flag" + "fmt" "log/slog" + "os" "github.com/grafana/pyroscope-go" - "github.com/martinlehoux/biking_home/cli" "github.com/martinlehoux/biking_home/config" + "github.com/martinlehoux/biking_home/mountain_pass" + "github.com/martinlehoux/biking_home/ride" + "github.com/martinlehoux/biking_home/web" "github.com/martinlehoux/kagamigo/kcore" _ "github.com/mattn/go-sqlite3" ) @@ -31,7 +35,63 @@ func main() { db, err := sql.Open("sqlite3", appConfig.Database.Path) kcore.Expect(err, "failed to open database") defer db.Close() - cli.Run(db, *configFile, appConfig, flag.Args(), *enablePprof) + runCommand(db, *configFile, appConfig, flag.Args(), *enablePprof) +} + +func runCommand(db *sql.DB, configPath string, appConfig config.Config, args []string, enablePprof bool) { + if len(args) == 0 { + web.ServeCmd(db, configPath, appConfig, enablePprof) + return + } + + switch args[0] { + case "fetch-osm": + mountain_pass.FetchOSM() + case "extract-osm": + if len(args) < 2 { + fmt.Fprintln(os.Stderr, "extract-osm requires a PBF file path argument") + printUsage() + os.Exit(2) + } + mountain_pass.ExtractOSM(db, args[1]) + case "backfill": + ride.BackfillCmd(db) + case "backtest": + ride.BacktestCmd(db) + case "elevation": + ride.ElevationCmd(db, args[1:]) + case "serve": + for _, arg := range args[1:] { + if arg == "--pprof" || arg == "-pprof" || arg == "pprof" { + enablePprof = true + } + } + web.ServeCmd(db, configPath, appConfig, enablePprof) + case "help", "-h", "--help": + printUsage() + default: + fmt.Fprintf(os.Stderr, "unknown command %q\n", args[0]) + printUsage() + os.Exit(2) + } +} + +func printUsage() { + fmt.Fprintf(os.Stderr, `Usage: biking_home [global flags] [args] + +Global flags: + -config path to YAML configuration file (default "config.yaml") + -pprof expose pprof endpoints at /debug/pprof (also: "serve --pprof") + +Commands: + serve start web server (default when no command given) + fetch-osm download the France OSM PBF into france-latest.osm.pbf + extract-osm extract mountain passes from an OSM PBF file + backfill recompute all stored ride values + backtest run data benchmarks comparing computed values against stored reference values + elevation analyse detect elevation outliers (tunnel spikes) + elevation fix linearly fix elevation between anchors +`) } // startPyroscope starts the continuous profiler when enabled in the config and diff --git a/mountain_pass/cli.go b/mountain_pass/cli.go new file mode 100644 index 0000000..ef8dfda --- /dev/null +++ b/mountain_pass/cli.go @@ -0,0 +1,39 @@ +package mountain_pass + +import ( + "context" + "database/sql" + "os" + + "github.com/martinlehoux/kagamigo/kcore" + "github.com/schollz/progressbar/v3" +) + +// ProgressBarEnabled reports whether stderr is attached to a terminal, so the +// progress bar only renders for interactive runs and stays out of piped or +// redirected output. +func ProgressBarEnabled() bool { + fi, err := os.Stderr.Stat() + return err == nil && fi.Mode()&os.ModeCharDevice != 0 +} + +func FetchOSM() { + err := FetchFrancePBF("france-latest.osm.pbf") + kcore.Expect(err, "failed to download France OSM PBF") +} + +func ExtractOSM(db *sql.DB, pbfPath string) { + var bar *progressbar.ProgressBar + _, err := ExtractMountainPasses(context.Background(), pbfPath, db, func(current, total int64) { + if bar == nil && ProgressBarEnabled() { + bar = progressbar.DefaultBytes(total, "Extracting mountain passes") + } + if bar != nil { + bar.Set64(current) + } + }) + if bar != nil { + bar.Finish() + } + kcore.Expect(err, "failed to extract mountain passes from OSM") +} diff --git a/ride/cli.go b/ride/cli.go new file mode 100644 index 0000000..a460260 --- /dev/null +++ b/ride/cli.go @@ -0,0 +1,481 @@ +package ride + +import ( + "database/sql" + "encoding/json" + "errors" + "fmt" + "log/slog" + "math" + "os" + "sort" + "strconv" + "strings" + "text/tabwriter" + "time" + + "github.com/martinlehoux/biking_home/climb" + "github.com/martinlehoux/biking_home/mountain_pass" + "github.com/martinlehoux/kagamigo/kcore" + "github.com/schollz/progressbar/v3" +) + +func BackfillCmd(db *sql.DB) { + var bar *progressbar.ProgressBar + count, err := Backfill(db, func(current, total int) { + if bar == nil && mountain_pass.ProgressBarEnabled() { + bar = progressbar.Default(int64(total), "Backfilling ride values") + } + if bar != nil { + bar.Set(current) + } + }) + if bar != nil { + bar.Finish() + } + kcore.Expect(err, "failed to backfill ride values") + slog.Info("Backfilled ride values", "rides", count) +} + +type backtestSample struct { + externalID string + name string + computed time.Duration + reference time.Duration + relErrorPct float64 +} + +func BacktestCmd(db *sql.DB) { + kcore.Expect(runBacktest(db), "failed to run backtest") +} + +func runBacktest(db *sql.DB) error { + items, err := List(db) + if err != nil { + return err + } + var samples []backtestSample + var bar *progressbar.ProgressBar + if mountain_pass.ProgressBarEnabled() { + bar = progressbar.Default(int64(len(items)), "Backtesting rides") + defer bar.Finish() + } + for _, item := range items { + if bar != nil { + bar.Add(1) + } + if !isBacktestEligible(item) { + continue + } + parsed, err := ParseFile(FITRideParser{}, item.FitPath) + if err != nil { + if errors.Is(err, ErrNoTrackPoints) { + continue + } + slog.Warn("Failed to parse ride FIT", "ride", item.ExternalID, "file", item.FitPath, "error", err) + continue + } + reference := time.Duration(item.ExternalMovingTimeS) * time.Second + computed := MovingTime(parsed) + samples = append(samples, backtestSample{ + externalID: item.ExternalID, + name: item.Name, + computed: computed, + reference: reference, + relErrorPct: (float64(computed) - float64(reference)) / float64(reference) * 100, + }) + } + if len(samples) == 0 { + slog.Info("No rides with FIT to backtest", "rides", len(items)) + return nil + } + sort.Slice(samples, func(i, j int) bool { + return math.Abs(samples[i].relErrorPct) > math.Abs(samples[j].relErrorPct) + }) + w := tabwriter.NewWriter(os.Stdout, 0, 0, 2, ' ', 0) + fmt.Fprintln(w, "computed\treference\terr %\tride") + limit := min(len(samples), 10) + for _, s := range samples[:limit] { + fmt.Fprintf(w, "%s\t%s\t%+.1f\t%s (%s)\n", s.computed.Round(time.Second), s.reference.Round(time.Second), s.relErrorPct, s.name, s.externalID) + } + w.Flush() + + absErrors := make([]float64, 0, len(samples)) + for _, s := range samples { + absErrors = append(absErrors, math.Abs(s.relErrorPct)) + } + percentiles := []float64{50, 75, 90, 95, 99} + distribution := errorDistribution(absErrors, percentiles) + table := tabwriter.NewWriter(os.Stdout, 0, 0, 2, ' ', 0) + fmt.Fprintln(table, "percentile\tabs err %") + for _, p := range percentiles { + fmt.Fprintf(table, "p%g\t%.1f\n", p, distribution[p]) + } + table.Flush() + slog.Info("Moving time backtest", "rides", len(samples), "mean_err_pct", math.Round(meanAbsErr(absErrors)*10)/10, "stderr_pct", math.Round(stdErrAbsErr(absErrors)*10)/10) + return nil +} + +func isBacktestEligible(item StoredRide) bool { + if item.FitPath == "" || item.ExternalMovingTimeS <= 0 || item.ElapsedTimeS <= 0 { + return false + } + if !item.IsCategorised() { + return false + } + if item.RideType == RideTypeIndoor || item.RideType == RideTypeTransport { + return false + } + return true +} + +func meanAbsErr(absErrors []float64) float64 { + var sum float64 + for _, err := range absErrors { + sum += err + } + return sum / float64(len(absErrors)) +} + +func stdErrAbsErr(absErrors []float64) float64 { + mean := meanAbsErr(absErrors) + var sumSquares float64 + for _, err := range absErrors { + sumSquares += (err - mean) * (err - mean) + } + variance := sumSquares / float64(len(absErrors)-1) + return math.Sqrt(variance / float64(len(absErrors))) +} + +func errorDistribution(absErrors []float64, percentiles []float64) map[float64]float64 { + sorted := append([]float64(nil), absErrors...) + sort.Float64s(sorted) + distribution := map[float64]float64{} + for _, p := range percentiles { + index := max(int(math.Ceil(p/100*float64(len(sorted)))-1), 0) + if index >= len(sorted) { + index = len(sorted) - 1 + } + distribution[p] = sorted[index] + } + return distribution +} + +func ElevationCmd(db *sql.DB, args []string) { + if len(args) == 0 { + fmt.Fprintln(os.Stderr, "elevation requires subcommand: analyse | fix") + printElevationUsage() + os.Exit(2) + } + switch args[0] { + case "analyse", "analyze": + kcore.Expect(runElevationAnalyse(db, args[1:]), "elevation analyse failed") + case "fix": + kcore.Expect(runElevationFix(db, args[1:]), "elevation fix failed") + default: + fmt.Fprintf(os.Stderr, "unknown elevation subcommand %q\n", args[0]) + printElevationUsage() + os.Exit(2) + } +} + +func printElevationUsage() { + fmt.Fprintf(os.Stderr, `Usage: + biking_home elevation analyse [--json] [--threshold ] + biking_home elevation fix --auto [--threshold ] [--dry-run] + biking_home elevation fix --from --to [--dry-run] + +Examples: + biking_home elevation analyse 754 + biking_home elevation analyse all --json | jq + biking_home elevation fix 754 --auto + biking_home elevation fix 754 --from 4.4km --to 4.8km + biking_home elevation fix 754 --from 927 --to 992 +`) +} + +// parseStoredRide parses the stored ride's route files, preferring FIT and +// falling back to GPX when FIT parsing fails or is missing. +func parseStoredRide(item StoredRide) (Ride, error) { + if item.FitPath == "" && item.GPXPath == "" { + return Ride{}, errors.New("no route files") + } + if item.FitPath != "" { + parsed, err := ParseFile(FITRideParser{}, item.FitPath) + if err == nil || item.GPXPath == "" { + return parsed, err + } + } + return ParseFile(GPXRideParser{}, item.GPXPath) +} + +type elevationAnalyseResult struct { + RideID int64 `json:"rideId"` + Name string `json:"name"` + Distance float64 `json:"distanceM"` + Cotacol float64 `json:"cotacol"` + Zones []FixZone `json:"zones"` +} + +func runElevationAnalyse(db *sql.DB, args []string) error { + var target string + var jsonOut bool + var threshold float64 = DefaultGradeThreshold + for i := 0; i < len(args); i++ { + switch args[i] { + case "--json": + jsonOut = true + case "--threshold": + if i+1 >= len(args) { + return errors.New("--threshold requires a value") + } + i++ + v, err := strconv.ParseFloat(args[i], 64) + if err != nil { + return fmt.Errorf("invalid threshold %q: %w", args[i], err) + } + threshold = v + default: + if strings.HasPrefix(args[i], "--") { + return fmt.Errorf("unknown flag %q", args[i]) + } + if target == "" { + target = args[i] + } else { + return fmt.Errorf("unexpected arg %q", args[i]) + } + } + } + if target == "" { + return errors.New("elevation analyse requires ") + } + var rides []StoredRide + if target == "all" { + all, err := List(db) + if err != nil { + return err + } + rides = all + } else { + id, err := strconv.ParseInt(target, 10, 64) + if err != nil { + return fmt.Errorf("invalid ride id %q", target) + } + item, found, err := GetByID(db, id) + if err != nil { + return err + } + if !found { + return fmt.Errorf("ride %d not found", id) + } + rides = []StoredRide{item} + } + results := make([]elevationAnalyseResult, 0, len(rides)) + for _, item := range rides { + parsed, err := parseStoredRide(item) + if err != nil { + slog.Warn("Failed to parse ride for elevation analyse", "ride", item.ID, "error", err) + continue + } + outliers := DetectElevationOutliers(parsed.Distances, parsed.Elevations, threshold) + if len(outliers) == 0 && target != "all" { + // still report empty + } else if len(outliers) == 0 { + continue + } + zones := SuggestFixZones(outliers) + cotacol := parsed.Cotacol() + results = append(results, elevationAnalyseResult{ + RideID: item.ID, + Name: item.Name, + Distance: item.DistanceM, + Cotacol: cotacol, + Zones: zones, + }) + } + if target == "all" { + sort.Slice(results, func(i, j int) bool { + maxI, maxJ := 0.0, 0.0 + for _, z := range results[i].Zones { + // parse reason grade not stored; use zone span as proxy + span := z.EndKm - z.StartKm + if span > maxI { + maxI = span + } + } + for _, z := range results[j].Zones { + span := z.EndKm - z.StartKm + if span > maxJ { + maxJ = span + } + } + return len(results[i].Zones) > len(results[j].Zones) || (len(results[i].Zones) == len(results[j].Zones) && maxI > maxJ) + }) + } + if jsonOut { + enc := json.NewEncoder(os.Stdout) + enc.SetIndent("", " ") + return enc.Encode(results) + } + if len(results) == 0 { + fmt.Println("No elevation outliers detected.") + return nil + } + w := tabwriter.NewWriter(os.Stdout, 0, 0, 2, ' ', 0) + fmt.Fprintln(w, "ride\tname\tcotacol\tzone\tkm\tgrade") + for _, r := range results { + for _, z := range r.Zones { + fmt.Fprintf(w, "%d\t%s\t%.1f\t%d→%d\t%.2f–%.2f\t%s\n", r.RideID, r.Name, r.Cotacol, z.StartIdx, z.EndIdx, z.StartKm, z.EndKm, z.Reason) + } + } + w.Flush() + slog.Info("Elevation analyse complete", "rides", len(results)) + return nil +} + +func runElevationFix(db *sql.DB, args []string) error { + var rideIDRaw string + var fromRaw, toRaw string + var auto bool + var dryRun bool + var threshold float64 = DefaultGradeThreshold + for i := 0; i < len(args); i++ { + switch args[i] { + case "--auto": + auto = true + case "--dry-run": + dryRun = true + case "--from": + if i+1 >= len(args) { + return errors.New("--from requires a value") + } + i++ + fromRaw = args[i] + case "--to": + if i+1 >= len(args) { + return errors.New("--to requires a value") + } + i++ + toRaw = args[i] + case "--threshold": + if i+1 >= len(args) { + return errors.New("--threshold requires a value") + } + i++ + v, err := strconv.ParseFloat(args[i], 64) + if err != nil { + return fmt.Errorf("invalid threshold %q: %w", args[i], err) + } + threshold = v + default: + if strings.HasPrefix(args[i], "--") { + return fmt.Errorf("unknown flag %q", args[i]) + } + if rideIDRaw == "" { + rideIDRaw = args[i] + } else { + return fmt.Errorf("unexpected arg %q", args[i]) + } + } + } + if rideIDRaw == "" { + return errors.New("elevation fix requires ") + } + if !auto && (fromRaw == "" || toRaw == "") { + return errors.New("elevation fix requires --auto or --from/--to") + } + if auto && (fromRaw != "" || toRaw != "") { + return errors.New("--auto cannot be combined with --from/--to") + } + id, err := strconv.ParseInt(rideIDRaw, 10, 64) + if err != nil { + return fmt.Errorf("invalid ride id %q", rideIDRaw) + } + item, found, err := GetByID(db, id) + if err != nil { + return err + } + if !found { + return fmt.Errorf("ride %d not found", id) + } + if item.FitPath == "" && item.GPXPath == "" { + return fmt.Errorf("ride %d has no route files", id) + } + parsed, err := parseStoredRide(item) + if err != nil { + return fmt.Errorf("parse ride %d: %w", id, err) + } + before := parsed.Cotacol() + var zones []FixZone + if auto { + outliers := DetectElevationOutliers(parsed.Distances, parsed.Elevations, threshold) + if len(outliers) == 0 { + fmt.Printf("Ride %d: no outliers detected (threshold %.0f%%)\n", id, threshold*100) + return nil + } + zones = SuggestFixZones(outliers) + } else { + fromIdx, err := ResolveIndex(parsed.Distances, fromRaw) + if err != nil { + return fmt.Errorf("invalid --from: %w", err) + } + toIdx, err := ResolveIndex(parsed.Distances, toRaw) + if err != nil { + return fmt.Errorf("invalid --to: %w", err) + } + if fromIdx >= toIdx { + return errors.New("--from must be before --to") + } + zones = []FixZone{{ + StartIdx: fromIdx, + EndIdx: toIdx, + StartKm: parsed.Distances[fromIdx] / 1000, + EndKm: parsed.Distances[toIdx] / 1000, + Reason: "manual", + }} + } + if dryRun { + fmt.Printf("Ride %d %q: would fix %d zone(s), cotacol %.1f -> preview\n", id, item.Name, len(zones), before) + for _, z := range zones { + fmt.Printf(" %d→%d %.3f–%.3f km %s\n", z.StartIdx, z.EndIdx, z.StartKm, z.EndKm, z.Reason) + } + // Preview cotacol after fix + elevCopy := make([]float64, len(parsed.Elevations)) + copy(elevCopy, parsed.Elevations) + LinearFix(parsed.Distances, elevCopy, zones) + afterPreview := climb.Cotacol(parsed.Distances, elevCopy) + fmt.Printf(" cotacol preview: %.1f -> %.1f (Δ %.1f)\n", before, afterPreview, afterPreview-before) + return nil + } + slog.Info("Fixing elevation", "ride", id, "zones", len(zones)) + if err := FixRideFiles(parsed, zones, item.GPXPath, item.FitPath); err != nil { + return err + } + // Re-parse to compute new cotacol and persist via Save (recomputes stored values from files). + // Reload item to get potentially derived paths + updated := item + // If one path was missing, FixRideFiles may have created it; update derived path for Save + if updated.FitPath == "" && updated.GPXPath != "" { + updated.FitPath = updated.GPXPath[:len(updated.GPXPath)-4] + ".fit" + if _, err := os.Stat(updated.FitPath); err != nil { + updated.FitPath = "" + } + } + if err := Save(db, updated); err != nil { + return fmt.Errorf("save ride %d: %w", id, err) + } + // Report + reparsed, _ := ParseFile(FITRideParser{}, updated.FitPath) + if reparsed.Len() == 0 && updated.GPXPath != "" { + reparsed, _ = ParseFile(GPXRideParser{}, updated.GPXPath) + } + after := 0.0 + if reparsed.Len() > 0 { + after = reparsed.Cotacol() + } + fmt.Printf("Ride %d %q fixed: %d zone(s), cotacol %.1f -> %.1f\n", id, item.Name, len(zones), before, after) + for _, z := range zones { + fmt.Printf(" %d→%d %.3f–%.3f km %s\n", z.StartIdx, z.EndIdx, z.StartKm, z.EndKm, z.Reason) + } + return nil +} diff --git a/ride/cli_test.go b/ride/cli_test.go new file mode 100644 index 0000000..7272836 --- /dev/null +++ b/ride/cli_test.go @@ -0,0 +1,54 @@ +package ride + +import ( + "testing" + + "github.com/stretchr/testify/assert" +) + +func TestBacktestEligibilityExcludesShortDistances(t *testing.T) { + short := StoredRide{FitPath: "fit", DistanceM: 10_000 - 1, ExternalMovingTimeS: 8_000, ElapsedTimeS: 10_000, BikeType: BikeTypeRoad, RideType: RideTypeTraining} + minimum := StoredRide{FitPath: "fit", DistanceM: 10_000, ExternalMovingTimeS: 8_000, ElapsedTimeS: 10_000, BikeType: BikeTypeRoad, RideType: RideTypeTraining} + + assert.True(t, isBacktestEligible(short)) + assert.True(t, isBacktestEligible(minimum)) +} + +func TestBacktestEligibilityExcludesLowMovingRatio(t *testing.T) { + low := StoredRide{FitPath: "fit", DistanceM: 10_000, ExternalMovingTimeS: 7_999, ElapsedTimeS: 10_000, BikeType: BikeTypeRoad, RideType: RideTypeTraining} + boundary := StoredRide{FitPath: "fit", DistanceM: 10_000, ExternalMovingTimeS: 8_000, ElapsedTimeS: 10_000, BikeType: BikeTypeRoad, RideType: RideTypeTraining} + noElapsed := StoredRide{FitPath: "fit", DistanceM: 10_000, ExternalMovingTimeS: 1, BikeType: BikeTypeRoad, RideType: RideTypeTraining} + + assert.True(t, isBacktestEligible(low)) + assert.True(t, isBacktestEligible(boundary)) + assert.False(t, isBacktestEligible(noElapsed)) +} + +func TestBacktestEligibilityExcludesUncategorisedAndIndoorTransport(t *testing.T) { + base := StoredRide{FitPath: "fit", ExternalMovingTimeS: 8_000, ElapsedTimeS: 10_000, BikeType: BikeTypeRoad, RideType: RideTypeTraining} + uncategorised := StoredRide{FitPath: "fit", ExternalMovingTimeS: 8_000, ElapsedTimeS: 10_000} + indoor := StoredRide{FitPath: "fit", ExternalMovingTimeS: 8_000, ElapsedTimeS: 10_000, BikeType: BikeTypeRoad, RideType: RideTypeIndoor} + transport := StoredRide{FitPath: "fit", ExternalMovingTimeS: 8_000, ElapsedTimeS: 10_000, BikeType: BikeTypeRoad, RideType: RideTypeTransport} + race := StoredRide{FitPath: "fit", ExternalMovingTimeS: 8_000, ElapsedTimeS: 10_000, BikeType: BikeTypeMTB, RideType: RideTypeRace} + + assert.True(t, isBacktestEligible(base)) + assert.False(t, isBacktestEligible(uncategorised)) + assert.False(t, isBacktestEligible(indoor)) + assert.False(t, isBacktestEligible(transport)) + assert.True(t, isBacktestEligible(race)) +} + +func TestBacktestStatsUseUnroundedSamples(t *testing.T) { + absErrors := []float64{0, 0.1, 0.1} + + assert.InDelta(t, 1.0/15, meanAbsErr(absErrors), 1e-12) + assert.InDelta(t, 1.0/30, stdErrAbsErr(absErrors), 1e-12) +} + +func TestErrorDistributionUsesNearestRank(t *testing.T) { + distribution := errorDistribution([]float64{1, 2, 3, 4}, []float64{50, 75, 99}) + + assert.Equal(t, 2.0, distribution[50]) + assert.Equal(t, 3.0, distribution[75]) + assert.Equal(t, 4.0, distribution[99]) +} diff --git a/web/cli.go b/web/cli.go new file mode 100644 index 0000000..f925a95 --- /dev/null +++ b/web/cli.go @@ -0,0 +1,18 @@ +package web + +import ( + "database/sql" + "log/slog" + + "github.com/martinlehoux/biking_home/config" + "github.com/martinlehoux/kagamigo/kcore" +) + +func ServeCmd(db *sql.DB, configPath string, appConfig config.Config, enablePprof bool) { + server := NewServer(db, configPath).WithPprof(enablePprof) + if enablePprof { + slog.Info("pprof enabled", "endpoint", appConfig.Server.PublicURL+"/debug/pprof/") + } + slog.Info("Starting web server", "address", appConfig.Server.PublicURL) + kcore.Expect(server.ListenAndServe(appConfig.Server.Address), "web server stopped") +} -- cgit v1.3