ytmusic: invalidate caches on Ctrl+R refresh (#218)

Author: bjarneo

external/ytmusic/cache.go

@@ -103,3 +103,9 @@ func (c *ytCache) setTracks(playlistID string, tracks []playlist.Track) {
 		FetchedAt: time.Now(),
 	}
 }
+
+func (c *ytCache) clear() {
+	c.Playlists = nil
+	c.PlaylistsAt = time.Time{}
+	c.Tracks = make(map[string]cachedTrackList)
+}

external/ytmusic/provider.go

@@ -116,6 +116,22 @@ func (b *baseProvider) initSession(interactive bool) error {
 func (b *baseProvider) ensureSession() error { return b.initSession(false) }
 func (b *baseProvider) authenticate() error  { return b.initSession(true) }
 
+// refresh clears playlist/track caches so the next call re-fetches from the
+// API. Classification is preserved — it's on disk in a separate file, rarely
+// changes, and re-classifying costs API quota.
+func (b *baseProvider) refresh() {
+	b.mu.Lock()
+	b.allPlaylists = nil
+	b.classified = nil
+	clear(b.trackCache)
+	dc := b.ensureDiskCache()
+	dc.clear()
+	snap := dc.snapshot()
+	b.mu.Unlock()
+
+	saveSnapshot(snap)
+}
+
 func (b *baseProvider) close() {
 	b.mu.Lock()
 	defer b.mu.Unlock()
@@ -445,6 +461,7 @@ type YouTubeMusicProvider struct {
 func (p *YouTubeMusicProvider) Name() string        { return "YouTube Music" }
 func (p *YouTubeMusicProvider) Authenticate() error { return p.base.authenticate() }
 func (p *YouTubeMusicProvider) Close()              { p.base.close() }
+func (p *YouTubeMusicProvider) Refresh()            { p.base.refresh() }
 func (p *YouTubeMusicProvider) Tracks(id string) ([]playlist.Track, error) {
 	return p.base.tracks(id)
 }
@@ -474,6 +491,7 @@ type YouTubeProvider struct {
 func (p *YouTubeProvider) Name() string        { return "YouTube" }
 func (p *YouTubeProvider) Authenticate() error { return p.base.authenticate() }
 func (p *YouTubeProvider) Close()              { /* shared base; closed via music provider */ }
+func (p *YouTubeProvider) Refresh()            { p.base.refresh() }
 func (p *YouTubeProvider) Tracks(id string) ([]playlist.Track, error) {
 	return p.base.tracks(id)
 }
@@ -503,6 +521,7 @@ type YouTubeAllProvider struct {
 func (p *YouTubeAllProvider) Name() string        { return "YouTube (All)" }
 func (p *YouTubeAllProvider) Authenticate() error { return p.base.authenticate() }
 func (p *YouTubeAllProvider) Close()              { /* shared base; closed via music provider */ }
+func (p *YouTubeAllProvider) Refresh()            { p.base.refresh() }
 func (p *YouTubeAllProvider) Tracks(id string) ([]playlist.Track, error) {
 	return p.base.tracks(id)
 }

external/ytmusic/provider_test.go

@@ -0,0 +1,63 @@
+package ytmusic
+
+import (
+	"testing"
+	"time"
+
+	"cliamp/playlist"
+)
+
+func TestRefreshInvalidatesAllCaches(t *testing.T) {
+	t.Setenv("HOME", t.TempDir())
+
+	b := newBase(nil, "client-id", "client-secret", false)
+
+	b.allPlaylists = []playlistEntry{{ID: "p1", Name: "One", TrackCount: 5}}
+	b.classified = map[string]bool{"p1": true}
+	b.trackCache["p1"] = []playlist.Track{{Path: "https://example/v", Title: "t"}}
+
+	dc := b.ensureDiskCache()
+	dc.setPlaylists(b.allPlaylists)
+	dc.setTracks("p1", b.trackCache["p1"])
+	saveSnapshot(dc.snapshot())
+
+	if !dc.playlistsFresh() {
+		t.Fatal("disk cache should be fresh before refresh")
+	}
+
+	b.refresh()
+
+	if b.allPlaylists != nil {
+		t.Error("allPlaylists not cleared")
+	}
+	if b.classified != nil {
+		t.Error("classified not cleared")
+	}
+	if len(b.trackCache) != 0 {
+		t.Errorf("trackCache not cleared: %d entries", len(b.trackCache))
+	}
+
+	if b.disk.playlistsFresh() {
+		t.Error("disk cache still reports fresh after refresh")
+	}
+	if !b.disk.PlaylistsAt.IsZero() {
+		t.Errorf("PlaylistsAt should be zero, got %v", b.disk.PlaylistsAt)
+	}
+	if len(b.disk.Playlists) != 0 {
+		t.Errorf("disk Playlists not cleared: %d entries", len(b.disk.Playlists))
+	}
+	if len(b.disk.Tracks) != 0 {
+		t.Errorf("disk Tracks not cleared: %d entries", len(b.disk.Tracks))
+	}
+
+	reloaded := loadYTCache()
+	if reloaded.playlistsFresh() {
+		t.Error("reloaded disk cache still fresh after refresh")
+	}
+	if !reloaded.PlaylistsAt.Equal(time.Time{}) {
+		t.Errorf("reloaded PlaylistsAt should be zero, got %v", reloaded.PlaylistsAt)
+	}
+	if len(reloaded.Tracks) != 0 {
+		t.Errorf("reloaded disk Tracks not cleared: %d entries", len(reloaded.Tracks))
+	}
+}

playlist/provider.go

@@ -40,3 +40,10 @@ type Provider interface {
 type Authenticator interface {
 	Authenticate() error
 }
+
+// Refresher is optionally implemented by providers that cache playlist or
+// track data and support invalidating that cache so the next Playlists() /
+// Tracks() call re-fetches from the source.
+type Refresher interface {
+	Refresh()
+}

ui/model/keys.go

@@ -321,6 +321,9 @@ func (m *Model) handleKey(msg tea.KeyPressMsg) tea.Cmd {
 			m.provSearch.cursor = 0
 		case "ctrl+r":
 			if m.provider != nil && !m.provLoading {
+				if r, ok := m.provider.(playlist.Refresher); ok {
+					r.Refresh()
+				}
 				m.providerLists = nil
 				m.provLoading = true
 				m.activeProviderPlaylistID = ""