fix: correct export mode behavior and cache refresh

- Fix rewatch logic in ExportMovieHistory to properly identify first vs subsequent viewings
- Add cache invalidation after export completion to ensure new exports appear immediately
- Add comprehensive test for movie history export with rewatch verification
- Improve export history refresh functionality

Fixes issues where:
- Individual mode showed aggregated results and vice versa
- New exports didn't appear in web interface without manual refresh

Author: JohanDevl

pkg/export/letterboxd.go

@@ -364,10 +364,23 @@ func (e *LetterboxdExporter) ExportMovieHistory(history []api.HistoryItem, apiCl
 	}
 
 	// Track which movies we've seen to determine rewatch
+	// Process from oldest to newest to correctly identify rewatches
 	seenMovies := make(map[string]bool)
+	rewatchMap := make(map[int]bool) // Map index to rewatch status
 
-	// Write history entries
-	for _, item := range sortedHistory {
+	// First pass: Process in reverse order (oldest first) to determine rewatch status
+	for i := len(sortedHistory) - 1; i >= 0; i-- {
+		item := sortedHistory[i]
+		if seenMovies[item.Movie.IDs.IMDB] {
+			rewatchMap[i] = true // This is a rewatch
+		} else {
+			rewatchMap[i] = false // First time watching this movie
+			seenMovies[item.Movie.IDs.IMDB] = true
+		}
+	}
+
+	// Write history entries (in newest to oldest order)
+	for i, item := range sortedHistory {
 		// Parse watched date
 		watchedDate := ""
 		if item.WatchedAt != "" {
@@ -382,12 +395,10 @@ func (e *LetterboxdExporter) ExportMovieHistory(history []api.HistoryItem, apiCl
 			rating = r
 		}
 
-		// Determine if this is a rewatch
+		// Determine if this is a rewatch using pre-calculated map
 		rewatch := "false"
-		if seenMovies[item.Movie.IDs.IMDB] {
+		if rewatchMap[i] {
 			rewatch = "true"
-		} else {
-			seenMovies[item.Movie.IDs.IMDB] = true
 		}
 
 		// Convert TMDB ID to string

pkg/export/letterboxd_test.go

@@ -835,4 +835,123 @@ func TestGetTimeInConfigTimezone(t *testing.T) {
 			assert.True(t, timeDiff.Seconds() < 5, "Time difference should be small")
 		})
 	}
+}
+
+func TestExportMovieHistory(t *testing.T) {
+	// Create a temporary directory for test exports
+	tmpDir, err := os.MkdirTemp("", "letterboxd_history_test")
+	if err != nil {
+		t.Fatalf("Failed to create temp directory: %v", err)
+	}
+	defer os.RemoveAll(tmpDir)
+
+	// Create test configuration
+	cfg := &config.Config{
+		Letterboxd: config.LetterboxdConfig{
+			ExportDir: tmpDir,
+		},
+		Export: config.ExportConfig{
+			Format:     "csv",
+			DateFormat: "2006-01-02",
+		},
+	}
+	log := &MockLogger{}
+
+	// Create test history with multiple viewings of the same movie
+	testHistory := []api.HistoryItem{
+		{
+			Movie: api.MovieInfo{
+				Title: "Test Movie",
+				Year:  2020,
+				IDs: api.MovieIDs{
+					IMDB: "tt1234567",
+					TMDB: 12345,
+				},
+			},
+			WatchedAt: "2023-06-01T12:00:00Z", // First viewing (oldest)
+			Action:    "watch",
+		},
+		{
+			Movie: api.MovieInfo{
+				Title: "Test Movie",
+				Year:  2020,
+				IDs: api.MovieIDs{
+					IMDB: "tt1234567",
+					TMDB: 12345,
+				},
+			},
+			WatchedAt: "2023-08-15T15:30:00Z", // Second viewing (rewatch)
+			Action:    "watch",
+		},
+		{
+			Movie: api.MovieInfo{
+				Title: "Another Movie",
+				Year:  2021,
+				IDs: api.MovieIDs{
+					IMDB: "tt7654321",
+					TMDB: 54321,
+				},
+			},
+			WatchedAt: "2023-07-10T18:45:00Z", // Single viewing
+			Action:    "watch",
+		},
+	}
+
+	// Create exporter and export
+	exporter := NewLetterboxdExporter(cfg, log)
+	err = exporter.ExportMovieHistory(testHistory, nil)
+	if err != nil {
+		t.Fatalf("Failed to export movie history: %v", err)
+	}
+
+	// Verify file exists
+	filePath := filepath.Join(tmpDir, "watched-history-test.csv")
+	if _, err := os.Stat(filePath); os.IsNotExist(err) {
+		t.Fatalf("Export file was not created at %s", filePath)
+	}
+
+	// Read and verify CSV content
+	content, err := os.ReadFile(filePath)
+	if err != nil {
+		t.Fatalf("Failed to read export file: %v", err)
+	}
+
+	// Parse CSV to verify rewatch logic
+	reader := csv.NewReader(strings.NewReader(string(content)))
+	records, err := reader.ReadAll()
+	if err != nil {
+		t.Fatalf("Failed to parse CSV: %v", err)
+	}
+
+	// Should have header + 3 records
+	if len(records) != 4 {
+		t.Fatalf("Expected 4 records (header + 3 data), got %d", len(records))
+	}
+
+	// Records should be sorted by date (newest first)
+	// So order should be: Aug 15 (rewatch=true), Jul 10 (rewatch=false), Jun 01 (rewatch=false)
+
+	// August 15 - Test Movie second viewing (should be marked as rewatch)
+	if records[1][0] != "Test Movie" || records[1][2] != "2023-08-15" {
+		t.Fatalf("First record should be Test Movie 2023-08-15, got %s %s", records[1][0], records[1][2])
+	}
+	if records[1][6] != "true" {
+		t.Fatalf("Second viewing should be marked as rewatch=true, got %s", records[1][6])
+	}
+
+	// July 10 - Another Movie single viewing
+	if records[2][0] != "Another Movie" || records[2][2] != "2023-07-10" {
+		t.Fatalf("Second record should be Another Movie 2023-07-10, got %s %s", records[2][0], records[2][2])
+	}
+	if records[2][6] != "false" {
+		t.Fatalf("Single viewing should be marked as rewatch=false, got %s", records[2][6])
+	}
+
+	// June 1 - Test Movie first viewing (should be marked as not a rewatch)
+	if records[3][0] != "Test Movie" || records[3][2] != "2023-06-01" {
+		t.Fatalf("Third record should be Test Movie 2023-06-01, got %s %s", records[3][0], records[3][2])
+	}
+	if records[3][6] != "false" {
+		t.Fatalf("First viewing should be marked as rewatch=false, got %s", records[3][6])
+	}
 } 

pkg/web/handlers/exports.go

@@ -69,6 +69,14 @@ type ExportCache struct {
 	cacheTTL  time.Duration
 }
 
+// invalidateCache clears the cache to force a refresh
+func (h *ExportsHandler) invalidateCache() {
+	h.cache.mu.Lock()
+	defer h.cache.mu.Unlock()
+	h.cache.exports = nil
+	h.cache.lastScan = time.Time{}
+}
+
 type ExportsHandler struct {
 	config         *config.Config
 	logger         logger.Logger
@@ -1013,6 +1021,12 @@ func (h *ExportsHandler) runExportAsync(exportID, exportType, historyMode string
 			"output":    string(output),
 		})
 	}
+	
+	// Invalidate cache to ensure new export appears in the list
+	h.invalidateCache()
+	h.logger.Info("web.export_cache_invalidated", map[string]interface{}{
+		"export_id": exportID,
+	})
 }
 
 // DownloadHandler handles file downloads