feat: query activities by day

Author: tduyng

core/storage.go

@@ -15,6 +15,7 @@ type SQLiteStorage struct {
 	db            *sql.DB
 	saveStmt      *sql.Stmt
 	getRecentStmt *sql.Stmt
+	getBetweenStmt *sql.Stmt
 	countStmt     *sql.Stmt
 }
 
@@ -101,6 +102,17 @@ func (s *SQLiteStorage) prepareStatements() error {
 		return fmt.Errorf("failed to prepare get recent statement: %w", err)
 	}
 
+	s.getBetweenStmt, err = s.db.Prepare(`
+		SELECT id, timestamp, lines, language, project, editor, file, 
+		       branch, is_write
+		FROM activities
+		WHERE timestamp >= ? AND timestamp < ?
+		ORDER BY timestamp ASC
+	`)
+	if err != nil {
+		return fmt.Errorf("failed to prepare get between statement: %w", err)
+	}
+
 	s.countStmt, err = s.db.Prepare("SELECT COUNT(*) FROM activities")
 	if err != nil {
 		return fmt.Errorf("failed to prepare count statement: %w", err)
@@ -199,8 +211,8 @@ func (s *SQLiteStorage) SaveActivity(activity Activity) error {
 			total_time = total_time + excluded.total_time,
 			total_lines = total_lines + excluded.total_lines,
 			main_language = CASE 
-				WHEN (SELECT total_time FROM daily_language_summary WHERE date = excluded.date AND language = excluded.main_language) > 
-				      (SELECT COALESCE(MAX(total_time), 0) FROM daily_language_summary WHERE date = excluded.date AND language = excluded.main_language)
+				WHEN (SELECT total_time FROM daily_language_summary WHERE date = excluded.date AND language = excluded.main_language) >= 
+				      (SELECT COALESCE(MAX(total_time), 0) FROM daily_language_summary WHERE date = excluded.date AND language = daily_project_summary.main_language)
 				THEN excluded.main_language
 				ELSE daily_project_summary.main_language
 			END,
@@ -238,6 +250,16 @@ func (s *SQLiteStorage) GetActivitiesSince(since time.Time) ([]Activity, error)
 	return scanActivities(rows, 1000)
 }
 
+func (s *SQLiteStorage) GetActivitiesBetween(from, to time.Time) ([]Activity, error) {
+	rows, err := s.getBetweenStmt.Query(from.Unix(), to.Unix())
+	if err != nil {
+		return nil, fmt.Errorf("failed to query activities: %w", err)
+	}
+	defer rows.Close()
+
+	return scanActivities(rows, 100)
+}
+
 func (s *SQLiteStorage) GetActivityCount() (int, error) {
 	var count int
 	err := s.countStmt.QueryRow().Scan(&count)
@@ -407,6 +429,14 @@ func (s *SQLiteStorage) RebuildSummaries() error {
 	projSummary := make(map[string]projAgg)
 	editorSummary := make(map[string]editorAgg)
 
+	// To track most used language per project per day during rebuild
+	type projLangKey struct {
+		date    string
+		project string
+		lang    string
+	}
+	projLangTime := make(map[projLangKey]float64)
+
 	var prevTS int64
 	for i, a := range activitiesList {
 		ts := a.timestamp
@@ -443,10 +473,18 @@ func (s *SQLiteStorage) RebuildSummaries() error {
 		ps := projSummary[projKey]
 		ps.totalTime += gap
 		ps.totalLines += a.lines
-		if a.language != "" {
+		ps.fileCount++
+
+		// Track time per language for this project/day
+		plk := projLangKey{date, a.project, a.language}
+		projLangTime[plk] += gap
+
+		// Update main language if this one now has more time
+		currentMainTime := projLangTime[projLangKey{date, a.project, ps.mainLanguage}]
+		if a.language != "" && (ps.mainLanguage == "" || projLangTime[plk] > currentMainTime) {
 			ps.mainLanguage = a.language
 		}
-		ps.fileCount++
+
 		projSummary[projKey] = ps
 
 		editorKey := date + "|" + a.editor
@@ -534,6 +572,9 @@ func (s *SQLiteStorage) Close() error {
 	if s.getRecentStmt != nil {
 		s.getRecentStmt.Close()
 	}
+	if s.getBetweenStmt != nil {
+		s.getBetweenStmt.Close()
+	}
 	if s.countStmt != nil {
 		s.countStmt.Close()
 	}

core/tracker_test.go

@@ -27,6 +27,16 @@ func (m *mockStorage) GetActivitiesSince(since time.Time) ([]Activity, error) {
 	return result, nil
 }
 
+func (m *mockStorage) GetActivitiesBetween(from, to time.Time) ([]Activity, error) {
+	var result []Activity
+	for _, a := range m.activities {
+		if !a.Timestamp.Before(from) && a.Timestamp.Before(to) {
+			result = append(result, a)
+		}
+	}
+	return result, nil
+}
+
 func (m *mockStorage) GetActivityCount() (int, error) {
 	return len(m.activities), nil
 }

core/types.go

@@ -61,6 +61,7 @@ type EditorRow struct {
 type Storage interface {
 	SaveActivity(Activity) error
 	GetActivitiesSince(time.Time) ([]Activity, error)
+	GetActivitiesBetween(from, to time.Time) ([]Activity, error)
 	GetActivityCount() (int, error)
 	GetPeriodSummary(from, to time.Time) (PeriodSummary, error)
 	GetLanguageSummary(from, to time.Time) ([]LanguageRow, error)

main.go

@@ -37,6 +37,8 @@ func main() {
 		handleToday()
 	case "projects":
 		handleProjects()
+	case "day":
+		handleDay(os.Args[2:])
 	case "api":
 		handleAPI(os.Args[2:])
 	case "optimize":
@@ -72,6 +74,7 @@ func printHelp() {
 	fmt.Println("  track      Track a file activity")
 	fmt.Println("  stats      Show statistics (pretty printed)")
 	fmt.Println("  today      Show today's activity")
+	fmt.Println("  day        Show stats for a specific day")
 	fmt.Println("  projects   Show project breakdown")
 	fmt.Println("  api        Output JSON for external tools (Neovim, etc)")
 	fmt.Println("  optimize   Optimize database (run monthly)")
@@ -220,6 +223,54 @@ func handleProjects() {
 	printProjectStats(apiStats)
 }
 
+func handleDay(args []string) {
+	fs := flag.NewFlagSet("day", flag.ExitOnError)
+	dateStr := fs.String("date", time.Now().Format("2006-01-02"), "Date in YYYY-MM-DD format")
+	compact := fs.Bool("compact", false, "Output compact JSON")
+	tzName := fs.String("tz", "", "Timezone name (e.g. America/New_York)")
+	fs.Parse(args)
+
+	dbPath, err := core.GetDefaultDBPath()
+	if err != nil {
+		fmt.Fprintf(os.Stderr, "Error resolving DB path: %v\n", err)
+		os.Exit(1)
+	}
+
+	storage, err := core.OpenReadOnlyStorage(dbPath)
+	if err != nil {
+		fmt.Fprintf(os.Stderr, "Error opening database: %v\n", err)
+		os.Exit(1)
+	}
+	defer storage.Close()
+
+	tz := time.Local
+	if *tzName != "" {
+		location, err := time.LoadLocation(*tzName)
+		if err != nil {
+			fmt.Fprintf(os.Stderr, "Error loading timezone: %v\n", err)
+			os.Exit(1)
+		}
+		tz = location
+	}
+
+	calc := stats.NewCalculator(tz)
+	dayStats, err := calc.CalculateDay(storage, *dateStr)
+	if err != nil {
+		fmt.Fprintf(os.Stderr, "Error calculating day stats: %v\n", err)
+		os.Exit(1)
+	}
+
+	encoder := json.NewEncoder(os.Stdout)
+	if !*compact {
+		encoder.SetIndent("", "  ")
+	}
+
+	if err := encoder.Encode(dayStats); err != nil {
+		fmt.Fprintf(os.Stderr, "Error encoding JSON: %v\n", err)
+		os.Exit(1)
+	}
+}
+
 func handleAPI(args []string) {
 	fs := flag.NewFlagSet("api", flag.ExitOnError)
 	compact := fs.Bool("compact", false, "Output compact JSON (no indentation)")

stats/api.go

@@ -83,15 +83,6 @@ func (c *Calculator) CalculateAPI(storage core.Storage, opts APIOptions) (*APISt
 		lifetimeHours[lr.Language] = lr.TotalTime / 3600
 	}
 
-	projectLangs := make(map[string]map[string]float64)
-	for _, pr := range allTimeProjs {
-		pl := make(map[string]float64)
-		for _, lr := range allTimeLangs {
-			pl[lr.Language] = lr.TotalTime / 3600
-		}
-		projectLangs[pr.Project] = pl
-	}
-
 	cutoff := time.Now().AddDate(0, 0, -opts.LoadRecentDays)
 	activities, err := storage.GetActivitiesSince(cutoff)
 	if err != nil {
@@ -104,6 +95,15 @@ func (c *Calculator) CalculateAPI(storage core.Storage, opts APIOptions) (*APISt
 	activities, sessions := sessionMgr.GroupAndCalculate(activities)
 	sessionsByDay := c.indexSessionsByDay(sessions)
 
+	// Build projectLangs map using durations from grouped activities
+	projectLangs := make(map[string]map[string]float64)
+	for _, a := range activities {
+		if projectLangs[a.Project] == nil {
+			projectLangs[a.Project] = make(map[string]float64)
+		}
+		projectLangs[a.Project][a.Language] += a.Duration
+	}
+
 	today := c.buildPeriodFromSummary("today", todaySummary, todayLangs, todayProjs, todayEditors, sessions, sessionsByDay, lifetimeHours, projectLangs, todayStart, now, activities)
 	yesterday := c.buildPeriodFromSummary("yesterday", yesterdaySummary, yesterdayLangs, yesterdayProjs, yesterdayEditors, sessions, sessionsByDay, lifetimeHours, projectLangs, yesterdayStart, todayStart, activities)
 	thisWeek := c.buildPeriodFromSummary("this_week", thisWeekSummary, thisWeekLangs, thisWeekProjs, thisWeekEditors, sessions, sessionsByDay, lifetimeHours, projectLangs, thisWeekStart, now, activities)
@@ -310,22 +310,62 @@ func (c *Calculator) convertLanguageRows(rows []core.LanguageRow, lifetimeHours
 func (c *Calculator) convertProjectRows(rows []core.ProjectRow, projectLangs map[string]map[string]float64, total float64) []APIProjectStats {
 	result := make([]APIProjectStats, 0, len(rows))
 	for _, r := range rows {
-		mainLang := r.MainLanguage
+		mainLang := ""
+
+		if langs, ok := projectLangs[r.Project]; ok {
+			// Priority 1: Most used actual programming language (CODE)
+			maxDur := -1.0
+			for lang, dur := range langs {
+				if IsCodeLanguage(lang) && dur > maxDur {
+					maxDur = dur
+					mainLang = lang
+				}
+			}
+
+			// Priority 2: Most used Documentation or Markup (Useful for notes/web)
+			if mainLang == "" {
+				maxDur = -1.0
+				for lang, dur := range langs {
+					class := GetLanguageClass(lang)
+					if (class == "doc" || class == "markup") && IsValidLanguage(lang) && dur > maxDur {
+						maxDur = dur
+						mainLang = lang
+					}
+				}
+			}
 
-		// If mainLang is not a code language, find the first code language from projectLangs
-		if mainLang == "" || !IsCodeLanguage(mainLang) {
-			if langs, ok := projectLangs[r.Project]; ok {
-				for lang := range langs {
-					if IsCodeLanguage(lang) {
+			// Priority 3: Most used Data or Config
+			if mainLang == "" {
+				maxDur = -1.0
+				for lang, dur := range langs {
+					class := GetLanguageClass(lang)
+					if (class == "data" || class == "config") && IsValidLanguage(lang) && dur > maxDur {
+						maxDur = dur
 						mainLang = lang
-						break
 					}
 				}
 			}
+
+			// Priority 4: Any other non-meta valid language
+			if mainLang == "" {
+				maxDur = -1.0
+				for lang, dur := range langs {
+					if IsValidLanguage(lang) && dur > maxDur {
+						maxDur = dur
+						mainLang = lang
+					}
+				}
+			}
+		}
+
+		// Fallback to the row's main language only if it's actually valid
+		if mainLang == "" && IsValidLanguage(r.MainLanguage) {
+			mainLang = r.MainLanguage
 		}
 
-		if mainLang == "" || !IsCodeLanguage(mainLang) {
-			mainLang = "Mixed"
+		// Final safety fallback
+		if mainLang == "" {
+			mainLang = "Project"
 		}
 
 		pct := 0.0