Initial commit: smartrun MVP

Garmin run classification and progression tracker. Go backend (MCP
client to mcp-garmin, SQLite store, deterministic rule engine, REST
API) and React/TS frontend (Dashboard, Review Queue, Workout Kinds).

Co-Authored-By: Claude Sonnet 5 <noreply@anthropic.com>

backend/internal/store/store_test.go

@@ -0,0 +1,202 @@
+package store
+
+import (
+	"context"
+	"path/filepath"
+	"testing"
+)
+
+func openTestDB(t *testing.T) *DB {
+	t.Helper()
+	path := filepath.Join(t.TempDir(), "smartrun_test.db")
+	db, err := Open(path)
+	if err != nil {
+		t.Fatalf("Open: %v", err)
+	}
+	t.Cleanup(func() { db.Close() })
+	return db
+}
+
+func f(v float64) *float64 { return &v }
+
+func TestMigrateIsIdempotent(t *testing.T) {
+	path := filepath.Join(t.TempDir(), "smartrun_test.db")
+	db1, err := Open(path)
+	if err != nil {
+		t.Fatalf("first Open: %v", err)
+	}
+	db1.Close()
+
+	db2, err := Open(path)
+	if err != nil {
+		t.Fatalf("second Open (re-applying migrations): %v", err)
+	}
+	db2.Close()
+}
+
+func TestUpsertActivity_InsertThenUpdateIsIdempotent(t *testing.T) {
+	db := openTestDB(t)
+	ctx := context.Background()
+
+	a := Activity{
+		GarminActivityID: 23554066504,
+		ActivityName:     "Auriol - W2-5-Base Endurance",
+		ActivityType:     "running",
+		StartTimeUTC:     "2026-07-11 05:02:35",
+		BeginTimestampMs: 1783746155000,
+		DurationSeconds:  1800,
+		DistanceMeters:   6858,
+		AvgHR:            f(148),
+		RawJSON:          `{"activityId":23554066504}`,
+	}
+
+	id, err := db.UpsertActivity(ctx, a)
+	if err != nil {
+		t.Fatalf("UpsertActivity (insert): %v", err)
+	}
+
+	a.AvgHR = f(150) // simulate a re-sync with a corrected value
+	id2, err := db.UpsertActivity(ctx, a)
+	if err != nil {
+		t.Fatalf("UpsertActivity (update): %v", err)
+	}
+	if id != id2 {
+		t.Fatalf("expected same internal id across upserts, got %d then %d", id, id2)
+	}
+
+	got, ok, err := db.GetActivity(ctx, id)
+	if err != nil || !ok {
+		t.Fatalf("GetActivity: ok=%v err=%v", ok, err)
+	}
+	if *got.AvgHR != 150 {
+		t.Errorf("AvgHR = %v, want 150 (update should have applied)", *got.AvgHR)
+	}
+
+	all, err := db.ListActivities(ctx, ActivityFilter{})
+	if err != nil {
+		t.Fatalf("ListActivities: %v", err)
+	}
+	if len(all) != 1 {
+		t.Fatalf("expected exactly 1 activity after upsert-update, got %d", len(all))
+	}
+}
+
+func TestKindAssignment_AppendOnlyHistoryAndCurrentView(t *testing.T) {
+	db := openTestDB(t)
+	ctx := context.Background()
+
+	activityID, err := db.UpsertActivity(ctx, Activity{
+		GarminActivityID: 1,
+		ActivityType:     "running",
+		StartTimeUTC:     "2026-07-11 05:00:00",
+		RawJSON:          "{}",
+	})
+	if err != nil {
+		t.Fatalf("UpsertActivity: %v", err)
+	}
+
+	kindID, err := db.CreateWorkoutKind(ctx, WorkoutKind{
+		Name:     "Tempo",
+		RuleJSON: `{"match":"all","conditions":[]}`,
+		IsActive: true,
+	})
+	if err != nil {
+		t.Fatalf("CreateWorkoutKind: %v", err)
+	}
+
+	// First: rule engine says needs_review (ambiguous).
+	if _, err := db.InsertKindAssignment(ctx, KindAssignment{
+		ActivityID:         activityID,
+		AssignmentSource:   AssignmentSourceRuleEngine,
+		Status:             AssignmentStatusNeedsReview,
+		CandidateKindsJSON: `[{"kind_id":1,"score":0.5}]`,
+	}); err != nil {
+		t.Fatalf("InsertKindAssignment (rule engine): %v", err)
+	}
+
+	queue, err := db.ReviewQueue(ctx)
+	if err != nil {
+		t.Fatalf("ReviewQueue: %v", err)
+	}
+	if len(queue) != 1 {
+		t.Fatalf("expected 1 item in review queue, got %d", len(queue))
+	}
+
+	// Then: user manually resolves it.
+	if _, err := db.InsertKindAssignment(ctx, KindAssignment{
+		ActivityID:       activityID,
+		WorkoutKindID:    &kindID,
+		AssignmentSource: AssignmentSourceManual,
+		Status:           AssignmentStatusAssigned,
+	}); err != nil {
+		t.Fatalf("InsertKindAssignment (manual): %v", err)
+	}
+
+	queue, err = db.ReviewQueue(ctx)
+	if err != nil {
+		t.Fatalf("ReviewQueue after resolve: %v", err)
+	}
+	if len(queue) != 0 {
+		t.Fatalf("expected 0 items in review queue after manual resolve, got %d", len(queue))
+	}
+
+	current, ok, err := db.CurrentAssignment(ctx, activityID)
+	if err != nil || !ok {
+		t.Fatalf("CurrentAssignment: ok=%v err=%v", ok, err)
+	}
+	if current.AssignmentSource != AssignmentSourceManual || current.Status != AssignmentStatusAssigned {
+		t.Errorf("current assignment = %+v, want manual/assigned", current)
+	}
+
+	// The original rule-engine assignment must still exist (append-only history).
+	var historyCount int
+	if err := db.QueryRowContext(ctx, `SELECT COUNT(*) FROM kind_assignments WHERE activity_id = ?`, activityID).Scan(&historyCount); err != nil {
+		t.Fatalf("count history: %v", err)
+	}
+	if historyCount != 2 {
+		t.Errorf("expected 2 historical assignment rows (rule engine + manual), got %d", historyCount)
+	}
+
+	forKind, err := db.AssignmentsForKind(ctx, kindID)
+	if err != nil {
+		t.Fatalf("AssignmentsForKind: %v", err)
+	}
+	if len(forKind) != 1 {
+		t.Fatalf("expected 1 assigned activity for kind %d, got %d", kindID, len(forKind))
+	}
+}
+
+func TestReplaceLapsIsIdempotent(t *testing.T) {
+	db := openTestDB(t)
+	ctx := context.Background()
+
+	activityID, err := db.UpsertActivity(ctx, Activity{
+		GarminActivityID: 2,
+		ActivityType:     "running",
+		StartTimeUTC:     "2026-07-11 05:00:00",
+		RawJSON:          "{}",
+	})
+	if err != nil {
+		t.Fatalf("UpsertActivity: %v", err)
+	}
+
+	laps := []Lap{
+		{LapIndex: 1, StartTimeUTC: "2026-07-11 05:00:00", DurationSeconds: 300, DistanceMeters: 1000, AvgHR: f(140), RawJSON: "{}"},
+		{LapIndex: 2, StartTimeUTC: "2026-07-11 05:05:00", DurationSeconds: 300, DistanceMeters: 1000, AvgHR: f(150), RawJSON: "{}"},
+	}
+	if err := db.ReplaceLaps(ctx, activityID, laps); err != nil {
+		t.Fatalf("ReplaceLaps (first): %v", err)
+	}
+	// Re-sync with a different set (e.g. corrected data) should fully replace, not append.
+	if err := db.ReplaceLaps(ctx, activityID, laps[:1]); err != nil {
+		t.Fatalf("ReplaceLaps (second): %v", err)
+	}
+
+	got, err := db.LapsForActivity(ctx, activityID)
+	if err != nil {
+		t.Fatalf("LapsForActivity: %v", err)
+	}
+	if len(got) != 1 {
+		t.Fatalf("expected 1 lap after replace, got %d", len(got))
+	}
+}