fix: timezone-agnostic generation

Author: Flyrell

internal/cli/generate.go

@@ -143,6 +143,9 @@ func runGenerate(
 		}
 	}
 
+	// Build a lookup from day date to first schedule window start
+	dayStartTimes := buildDayStartTimes(daySchedules)
+
 	// Compute checkout attribution for each month in range
 	entries, err := buildGenerateEntries(checkouts, daySchedules, from, to, now)
 	if err != nil {
@@ -181,9 +184,13 @@ func runGenerate(
 	generatedDays := make(map[string]bool)
 	for _, ge := range entries {
 		dt, _ := time.Parse("2006-01-02", ge.Date)
+		startHour, startMin := 9, 0 // fallback
+		if tod, ok := dayStartTimes[ge.Date]; ok {
+			startHour, startMin = tod.Hour, tod.Minute
+		}
 		e := entry.Entry{
 			ID:        hashutil.GenerateID("generate"),
-			Start:     time.Date(dt.Year(), dt.Month(), dt.Day(), 9, 0, 0, 0, time.UTC),
+			Start:     time.Date(dt.Year(), dt.Month(), dt.Day(), startHour, startMin, 0, 0, time.UTC),
 			Minutes:   ge.Minutes,
 			Message:   ge.Branch,
 			Task:      ge.Branch,
@@ -389,6 +396,18 @@ func buildGenerateEntries(
 	return result, nil
 }
 
+// buildDayStartTimes returns a map from date string to the first schedule
+// window's start time for that day.
+func buildDayStartTimes(daySchedules []schedule.DaySchedule) map[string]schedule.TimeOfDay {
+	m := make(map[string]schedule.TimeOfDay)
+	for _, ds := range daySchedules {
+		if len(ds.Windows) > 0 {
+			m[ds.Date.Format("2006-01-02")] = ds.Windows[0].From
+		}
+	}
+	return m
+}
+
 // deleteGeneratedEntries deletes log entries with source="generate" that fall
 // on the given dates.
 func deleteGeneratedEntries(homeDir, slug string, dates []string) error {

internal/cli/generate_test.go

@@ -9,6 +9,7 @@ import (
 
 	"github.com/Flyrell/hourgit/internal/entry"
 	"github.com/Flyrell/hourgit/internal/project"
+	"github.com/Flyrell/hourgit/internal/schedule"
 	"github.com/stretchr/testify/assert"
 	"github.com/stretchr/testify/require"
 )
@@ -209,6 +210,105 @@ func TestGenerateByProjectFlag(t *testing.T) {
 	assert.Contains(t, stdout.String(), "Generated")
 }
 
+func TestGenerateEntryStartMatchesSchedule(t *testing.T) {
+	homeDir, repoDir, proj := setupGenerateTest(t)
+	pk := PromptKit{Confirm: AlwaysYes()}
+
+	// Set a schedule starting at midnight (0:00-8:00)
+	err := project.SetSchedules(homeDir, proj.ID, []schedule.ScheduleEntry{
+		{
+			RRule:  "FREQ=WEEKLY;BYDAY=MO,TU,WE,TH,FR",
+			Ranges: []schedule.TimeRange{{From: "00:00", To: "08:00"}},
+		},
+	})
+	require.NoError(t, err)
+
+	// Monday June 16, 2025 — checkout at midnight, now at 7:55
+	mondayNow := func() time.Time {
+		return time.Date(2025, 6, 16, 7, 55, 0, 0, time.UTC)
+	}
+
+	co := entry.CheckoutEntry{
+		ID:        "co1",
+		Timestamp: time.Date(2025, 6, 16, 0, 0, 0, 0, time.UTC),
+		Previous:  "main",
+		Next:      "feature-midnight",
+	}
+	require.NoError(t, entry.WriteCheckoutEntry(homeDir, proj.Slug, co))
+
+	stdout := new(bytes.Buffer)
+	cmd := generateCmd
+	cmd.SetOut(stdout)
+	err = runGenerate(cmd, homeDir, repoDir, "", "", "", true, false, false, pk, mondayNow)
+	require.NoError(t, err)
+
+	// Verify the generated entry starts at 00:00, not 09:00
+	logs, err := entry.ReadAllEntries(homeDir, proj.Slug)
+	require.NoError(t, err)
+	require.GreaterOrEqual(t, len(logs), 1)
+
+	var found *entry.Entry
+	for i, l := range logs {
+		if l.Task == "feature-midnight" && l.Source == "generate" {
+			found = &logs[i]
+			break
+		}
+	}
+	require.NotNil(t, found, "expected a generated entry with task=feature-midnight")
+	assert.Equal(t, 0, found.Start.Hour(), "entry should start at hour 0")
+	assert.Equal(t, 0, found.Start.Minute(), "entry should start at minute 0")
+	assert.Equal(t, 475, found.Minutes, "expected 7h55m = 475 minutes")
+}
+
+func TestGenerateNonUTCTimezone(t *testing.T) {
+	homeDir, repoDir, proj := setupGenerateTest(t)
+	pk := PromptKit{Confirm: AlwaysYes()}
+
+	// Set a schedule starting at midnight (0:00-8:00)
+	err := project.SetSchedules(homeDir, proj.ID, []schedule.ScheduleEntry{
+		{
+			RRule:  "FREQ=WEEKLY;BYDAY=MO,TU,WE,TH,FR",
+			Ranges: []schedule.TimeRange{{From: "00:00", To: "08:00"}},
+		},
+	})
+	require.NoError(t, err)
+
+	loc := time.FixedZone("UTC+1", 1*60*60)
+
+	// Monday June 16, 2025 — checkout at local midnight (23:00 UTC), now at 7:55 local (6:55 UTC)
+	mondayNow := func() time.Time {
+		return time.Date(2025, 6, 16, 7, 55, 0, 0, loc)
+	}
+
+	co := entry.CheckoutEntry{
+		ID:        "co1",
+		Timestamp: time.Date(2025, 6, 15, 23, 0, 0, 0, time.UTC), // = 00:00 UTC+1 on June 16
+		Previous:  "main",
+		Next:      "feature-tz",
+	}
+	require.NoError(t, entry.WriteCheckoutEntry(homeDir, proj.Slug, co))
+
+	stdout := new(bytes.Buffer)
+	cmd := generateCmd
+	cmd.SetOut(stdout)
+	err = runGenerate(cmd, homeDir, repoDir, "", "", "", true, false, false, pk, mondayNow)
+	require.NoError(t, err)
+
+	logs, err := entry.ReadAllEntries(homeDir, proj.Slug)
+	require.NoError(t, err)
+
+	var found *entry.Entry
+	for i, l := range logs {
+		if l.Task == "feature-tz" && l.Source == "generate" {
+			found = &logs[i]
+			break
+		}
+	}
+	require.NotNil(t, found, "expected a generated entry with task=feature-tz")
+	// Should be 7h55m (local midnight to 7:55 local), not 6h55m
+	assert.Equal(t, 475, found.Minutes, "expected 7h55m = 475 minutes")
+}
+
 func TestGenerateRegisteredAsSubcommand(t *testing.T) {
 	root := newRootCmd()
 	names := make([]string, len(root.Commands()))

internal/timetrack/timetrack.go

@@ -123,21 +123,23 @@ func buildLogBucket(logs []entry.Entry, year int, month time.Month) (map[string]
 }
 
 // buildCheckoutBucket computes per-branch, per-day minutes from checkout entries
-// clipped to schedule windows.
+// clipped to schedule windows. Schedule window times are interpreted in the
+// timezone of `now` (the user's local timezone).
 func buildCheckoutBucket(
 	checkouts []entry.CheckoutEntry,
 	year int, month time.Month, daysInMonth int,
 	scheduleWindows map[int][]schedule.TimeWindow,
 	now time.Time,
 ) map[string]map[int]int {
+	loc := now.Location()
 	sorted := make([]entry.CheckoutEntry, len(checkouts))
 	copy(sorted, checkouts)
 	sort.Slice(sorted, func(i, j int) bool {
 		return sorted[i].Timestamp.Before(sorted[j].Timestamp)
 	})
 
-	monthStart := time.Date(year, month, 1, 0, 0, 0, 0, time.UTC)
-	monthEnd := time.Date(year, month, daysInMonth, 23, 59, 59, 0, time.UTC)
+	monthStart := time.Date(year, month, 1, 0, 0, 0, 0, loc)
+	monthEnd := time.Date(year, month, daysInMonth, 23, 59, 59, 0, loc)
 
 	var pairs []checkoutRange
 	lastBeforeIdx := -1
@@ -188,7 +190,7 @@ func buildCheckoutBucket(
 			if !ok {
 				continue
 			}
-			mins := overlapMinutes(p.from, p.to, year, month, day, windows)
+			mins := overlapMinutes(p.from, p.to, year, month, day, windows, loc)
 			if mins > 0 {
 				checkoutBucket[p.branch][day] += mins
 			}
@@ -298,12 +300,13 @@ func windowMinutes(w schedule.TimeWindow) int {
 }
 
 // overlapMinutes computes how many minutes of the checkout range [from, to)
-// overlap with the given schedule windows on a specific day.
-func overlapMinutes(from, to time.Time, year int, month time.Month, day int, windows []schedule.TimeWindow) int {
+// overlap with the given schedule windows on a specific day. Schedule window
+// times are interpreted in the given location (the user's local timezone).
+func overlapMinutes(from, to time.Time, year int, month time.Month, day int, windows []schedule.TimeWindow, loc *time.Location) int {
 	total := 0
 	for _, w := range windows {
-		wStart := time.Date(year, month, day, w.From.Hour, w.From.Minute, 0, 0, time.UTC)
-		wEnd := time.Date(year, month, day, w.To.Hour, w.To.Minute, 0, 0, time.UTC)
+		wStart := time.Date(year, month, day, w.From.Hour, w.From.Minute, 0, 0, loc)
+		wEnd := time.Date(year, month, day, w.To.Hour, w.To.Minute, 0, 0, loc)
 
 		// Overlap: max(from, wStart) to min(to, wEnd)
 		overlapStart := from

internal/timetrack/timetrack_test.go

@@ -211,6 +211,42 @@ func TestBuildReport_LastCheckoutCappedAtNow(t *testing.T) {
 	assert.Equal(t, 240, report.Rows[0].TotalMinutes)
 }
 
+func TestBuildReport_ScheduleWindowsInterpretedInLocalTimezone(t *testing.T) {
+	year, month := 2025, time.January
+	loc := time.FixedZone("UTC+1", 1*60*60)
+
+	// Schedule: 0:00-8:00 (user means local midnight to 8am local)
+	days := []schedule.DaySchedule{
+		{
+			Date: time.Date(year, month, 2, 0, 0, 0, 0, time.UTC),
+			Windows: []schedule.TimeWindow{
+				{
+					From: schedule.TimeOfDay{Hour: 0, Minute: 0},
+					To:   schedule.TimeOfDay{Hour: 8, Minute: 0},
+				},
+			},
+		},
+	}
+
+	// Checkout at local midnight (00:00 UTC+1 = 23:00 UTC day before)
+	checkouts := []entry.CheckoutEntry{
+		{ID: "c1", Timestamp: time.Date(2025, 1, 1, 23, 0, 0, 0, time.UTC), Previous: "main", Next: "feature-x"},
+	}
+
+	// "now" is 7:55 local (UTC+1) = 6:55 UTC.
+	// With UTC-interpreted windows: overlap of [23:00 UTC, 6:55 UTC] with
+	// [00:00 UTC, 08:00 UTC] = 6h55m (wrong).
+	// With local-interpreted windows: overlap of [23:00 UTC, 6:55 UTC] with
+	// [23:00 UTC, 07:00 UTC] (= 00:00-08:00 UTC+1) = 7h55m (correct).
+	now := time.Date(2025, 1, 2, 7, 55, 0, 0, loc) // = 6:55 UTC
+
+	report := BuildReport(checkouts, nil, days, year, month, now, nil)
+
+	assert.Equal(t, 1, len(report.Rows))
+	assert.Equal(t, "feature-x", report.Rows[0].Name)
+	assert.Equal(t, 475, report.Rows[0].Days[2]) // 7h55m = 475 min
+}
+
 func findRow(report ReportData, name string) *TaskRow {
 	for i := range report.Rows {
 		if report.Rows[i].Name == name {