≡
10-Band Equalizer
Parametric EQ presets plus a persistent Custom curve that survives preset changes and restarts.
◈
Themes & Visualizers
21 contrast-checked built-in themes and spectrum, waveform, particle, and true-stereo modes. Stereo provides dedicated L/R horizontal LED peak meters. Hot-swap with t / v.
-
☰
Playlists
TOML playlists with dynamic directory sources (--dir), M3U/M3U8/PLS import/export, duplicate-safe writes, and TUI/CLI sort tools.
+
☰
Playlists
TOML playlists with dynamic [[dir]] directory sources you can add, remove, and toggle-recursive from the playlist manager (D), cross-playlist favorites (n), M3U/M3U8/PLS import/export, duplicate-safe writes, and TUI/CLI sort tools.
⟲
Recently Played
Auto-recorded listening history. Browse it as a virtual playlist or run cliamp history from the shell.
→
HTTP Streaming
Play from URLs, internet radio, remote M3U playlists, and HLS (.m3u8) live streams via ffmpeg.
♪
Synced Lyrics
Embedded local lyrics first, then LRCLIB/NetEase fallback. Auto-scrolling for timestamped lyrics.
diff --git a/ui/model/command_registry.go b/ui/model/command_registry.go
index 8bc974305..5901a3fe0 100644
--- a/ui/model/command_registry.go
+++ b/ui/model/command_registry.go
@@ -5,6 +5,7 @@ import (
"charm.land/lipgloss/v2"
+ "github.com/bjarneo/cliamp/history"
"github.com/bjarneo/cliamp/ui"
)
@@ -26,6 +27,7 @@ const (
commandModeNavSearch
commandModePlaylistManager
commandModePlaylistManagerInput
+ commandModePlaylistManagerDirs
commandModePlaylistPicker
commandModePlaylistPickerInput
commandModeQueue
@@ -94,6 +96,7 @@ var commandRegistry = []commandSpec{
{Mode: commandModeMain, Keys: []string{"shift+up", "shift+down"}, KeyLabel: "Shift+Up Down", Label: "Move track up/down", Keymap: true},
{Mode: commandModeMain, Keys: []string{"h", "l"}, KeyLabel: "h l", Label: "EQ cursor left/right", Keymap: true},
{Mode: commandModeMain, Keys: []string{"enter"}, KeyLabel: "Enter", Label: "Play selected track", Keymap: true, ContextHelp: true, Primary: true},
+ {Mode: commandModeMain, Keys: []string{"f", "n"}, KeyLabel: "f/n", Label: "★/♥", Keymap: true, ContextHelp: true},
{Mode: commandModeMain, Keys: []string{"a"}, KeyLabel: "a", Label: "Toggle queue (play next)", Keymap: true, ContextHelp: true},
{Mode: commandModeMain, Keys: []string{"A"}, KeyLabel: "A", Label: "Queue manager", Keymap: true},
{Mode: commandModeMain, Keys: []string{"x"}, KeyLabel: "x", Label: "Remove selected track from playlist", Destructive: true, Keymap: true},
@@ -121,7 +124,6 @@ var commandRegistry = []commandSpec{
return !m.heightExpanded && m.layout.bodyRows > m.plVisible
}},
{Mode: commandModeMain, Keys: []string{"/"}, KeyLabel: "/", Label: "Filter/search list", Keymap: true, ContextHelp: true},
- {Mode: commandModeMain, Keys: []string{"f"}, KeyLabel: "f", Label: "Toggle bookmark/favorite", Keymap: true},
{Mode: commandModeMain, Keys: []string{"ctrl+f"}, KeyLabel: "Ctrl+F", Label: "Search active provider or YouTube", Keymap: true, ContextHelp: true},
{Mode: commandModeMain, Keys: []string{"u"}, KeyLabel: "u", Label: "Load URL (stream/playlist)", Keymap: true},
{Mode: commandModeMain, Keys: []string{"d"}, KeyLabel: "d", Label: "Audio device picker", Keymap: true},
@@ -167,6 +169,24 @@ var commandRegistry = []commandSpec{
{Mode: commandModeLyrics, Keys: []string{"r"}, KeyLabel: "r", Label: "Retry", ContextHelp: true, Primary: true, Enabled: func(m Model) bool { return !m.lyrics.loading && (m.lyrics.err != nil || len(m.lyrics.lines) == 0) }},
{Mode: commandModeLyrics, Keys: []string{"esc"}, KeyLabel: "Esc", Label: "Close", ContextHelp: true, Cancel: true},
{Mode: commandModeInfo, Keys: []string{"esc"}, KeyLabel: "Esc", Label: "Close", ContextHelp: true, Cancel: true},
+
+ {Mode: commandModePlaylistManager, Keys: []string{"D"}, KeyLabel: "D", Label: "Dir sources", ContextHelp: true, Enabled: func(m Model) bool {
+ return m.plManager.visible && m.plManager.screen == plMgrScreenTracks && m.plManager.selPlaylist != history.PlaylistName
+ }},
+ {Mode: commandModePlaylistManager, Keys: []string{"f", "n"}, KeyLabel: "f/n", Label: "★/♥", ContextHelp: true, Enabled: func(m Model) bool {
+ return m.plManager.visible && m.plManager.screen == plMgrScreenTracks
+ }},
+ {Mode: commandModePlaylistManager, Keys: []string{"[", "]"}, KeyLabel: "[ ]", Label: "Reorder", ContextHelp: true, Enabled: func(m Model) bool {
+ return m.plManager.visible && m.plManager.screen == plMgrScreenTracks
+ }},
+ {Mode: commandModePlaylistManagerDirs, Keys: []string{"esc", "backspace", "h", "left"}, KeyLabel: "Esc", Label: "Back to tracks", ContextHelp: true, Cancel: true},
+ {Mode: commandModePlaylistManagerDirs, Keys: []string{"a"}, KeyLabel: "a", Label: "Add dir", ContextHelp: true, Primary: true},
+ {Mode: commandModePlaylistManagerDirs, Keys: []string{"d"}, KeyLabel: "d", Label: "Remove", Destructive: true, ContextHelp: true},
+ {Mode: commandModePlaylistManagerDirs, Keys: []string{"r"}, KeyLabel: "r", Label: "Toggle recursive", ContextHelp: true},
+ {Mode: commandModePlaylistManagerDirs, Keys: []string{"up", "down", "k", "j"}, KeyLabel: "Up Down", Label: "Navigate", ContextHelp: true},
+ {Mode: commandModeFileBrowser, Keys: []string{"D"}, KeyLabel: "D", Label: "Add as dir source", ContextHelp: true, Enabled: func(m Model) bool {
+ return m.fileBrowser.visible && m.fileBrowser.targetPlaylist != ""
+ }},
}
func (m Model) commandHelp(mode commandMode) string {
diff --git a/ui/model/dirs_screen_test.go b/ui/model/dirs_screen_test.go
new file mode 100644
index 000000000..89eada2a3
--- /dev/null
+++ b/ui/model/dirs_screen_test.go
@@ -0,0 +1,342 @@
+package model
+
+import (
+ "errors"
+ "strings"
+ "testing"
+
+ tea "charm.land/bubbletea/v2"
+
+ "github.com/bjarneo/cliamp/playlist"
+ "github.com/bjarneo/cliamp/ui"
+)
+
+// dirSourceTestProvider is a local provider that also implements
+// provider.PlaylistDirSourceManager, so the manager's directory-sources screen
+// can be exercised without touching the filesystem.
+type dirSourceTestProvider struct {
+ commandsTestProvider
+ dirs []playlist.DirSource
+ removed []string
+ setRec []dirSetRecCall
+ added []string
+ failOn map[string]error // dirs that AddDirSource should fail on
+ favPaths map[string]struct{}
+}
+
+type dirSetRecCall struct {
+ dir string
+ recursive bool
+}
+
+func (p *dirSourceTestProvider) DirSources(string) ([]playlist.DirSource, error) {
+ return p.dirs, nil
+}
+func (p *dirSourceTestProvider) AddDirSource(_, dir string) (bool, error) {
+ if p.failOn != nil {
+ if err, ok := p.failOn[dir]; ok {
+ return false, err
+ }
+ }
+ for _, d := range p.dirs {
+ if d.Path == dir {
+ return false, nil
+ }
+ }
+ p.dirs = append(p.dirs, playlist.DirSource{Path: dir, Recursive: true})
+ p.added = append(p.added, dir)
+ return true, nil
+}
+func (p *dirSourceTestProvider) RemoveDirSource(_, dir string) error {
+ p.removed = append(p.removed, dir)
+ out := p.dirs[:0]
+ for _, d := range p.dirs {
+ if d.Path != dir {
+ out = append(out, d)
+ }
+ }
+ p.dirs = out
+ return nil
+}
+func (p *dirSourceTestProvider) SetDirRecursive(_, dir string, recursive bool) error {
+ p.setRec = append(p.setRec, dirSetRecCall{dir, recursive})
+ for i := range p.dirs {
+ if p.dirs[i].Path == dir {
+ p.dirs[i].Recursive = recursive
+ }
+ }
+ return nil
+}
+
+func (p *dirSourceTestProvider) ToggleFavorite(track playlist.Track) (bool, error) {
+ if p.favPaths == nil {
+ p.favPaths = make(map[string]struct{})
+ }
+ if _, ok := p.favPaths[track.Path]; ok {
+ delete(p.favPaths, track.Path)
+ return false, nil
+ }
+ p.favPaths[track.Path] = struct{}{}
+ return true, nil
+}
+
+func (p *dirSourceTestProvider) IsFavorited(path string) bool {
+ if p.favPaths == nil {
+ return false
+ }
+ _, ok := p.favPaths[path]
+ return ok
+}
+
+func (p *dirSourceTestProvider) FavoritesCount() int {
+ return len(p.favPaths)
+}
+
+func (p *dirSourceTestProvider) Tracks(id string) ([]playlist.Track, error) {
+ if id == "Favorites" && p.favPaths != nil {
+ var out []playlist.Track
+ for path := range p.favPaths {
+ out = append(out, playlist.Track{Path: path, Title: path})
+ }
+ return out, nil
+ }
+ return nil, nil
+}
+
+func newDirsScreenTestModel(prov *dirSourceTestProvider) Model {
+ m := Model{
+ playlist: playlist.New(),
+ localProvider: prov,
+ provider: prov,
+ favMgr: prov,
+ vis: ui.NewVisualizer(48000),
+ plManager: plManagerState{
+ visible: true,
+ screen: plMgrScreenTracks,
+ selPlaylist: "music",
+ tracks: []playlist.Track{{Path: "/a.mp3", Title: "A"}},
+ },
+ }
+ return m
+}
+
+func TestPlMgrDKeyOpensDirsScreen(t *testing.T) {
+ prov := &dirSourceTestProvider{
+ dirs: []playlist.DirSource{{Path: "/home/me/Music", Recursive: true}},
+ }
+ m := newDirsScreenTestModel(prov)
+
+ m.handlePlaylistManagerKey(tea.KeyPressMsg{Text: "D"})
+
+ if m.plManager.screen != plMgrScreenDirs {
+ t.Fatalf("screen = %v, want plMgrScreenDirs", m.plManager.screen)
+ }
+ if len(m.plManager.dirs) != 1 || m.plManager.dirs[0].Path != "/home/me/Music" {
+ t.Fatalf("dirs = %+v, want the loaded source", m.plManager.dirs)
+ }
+}
+
+func TestPlMgrDKeyHistoryShowsNotice(t *testing.T) {
+ prov := &dirSourceTestProvider{}
+ m := newDirsScreenTestModel(prov)
+ m.plManager.selPlaylist = "Recently Played"
+
+ m.handlePlaylistManagerKey(tea.KeyPressMsg{Text: "D"})
+
+ if m.plManager.screen != plMgrScreenTracks {
+ t.Fatalf("screen = %v, want to stay on Tracks for the virtual history playlist", m.plManager.screen)
+ }
+ if len(prov.dirs) != 0 {
+ t.Fatalf("DirSources should not be called for history, dirs = %+v", prov.dirs)
+ }
+ if m.status.text == "" {
+ t.Fatal("expected a status notice for the virtual history playlist")
+ }
+}
+
+func TestPlMgrDKeyNoticeWhenUnsupported(t *testing.T) {
+ // A plain commandsTestProvider does not implement PlaylistDirSourceManager,
+ // so the D key must show a notice and stay on the tracks screen.
+ plain := commandsTestProvider{name: "Local"}
+ m := newDirsScreenTestModel(&dirSourceTestProvider{})
+ m.localProvider = plain
+ m.provider = plain
+
+ m.handlePlaylistManagerKey(tea.KeyPressMsg{Text: "D"})
+
+ if m.plManager.screen != plMgrScreenTracks {
+ t.Fatalf("screen = %v, want to stay on Tracks when unsupported", m.plManager.screen)
+ }
+ if m.status.text == "" {
+ t.Fatal("expected a status notice when the provider lacks dir sources")
+ }
+}
+
+func TestPlMgrDirsToggleRecursive(t *testing.T) {
+ prov := &dirSourceTestProvider{
+ dirs: []playlist.DirSource{{Path: "/Music", Recursive: true}},
+ }
+ m := newDirsScreenTestModel(prov)
+ m.handlePlaylistManagerKey(tea.KeyPressMsg{Text: "D"}) // open dirs screen
+
+ m.handlePlaylistManagerKey(tea.KeyPressMsg{Text: "r"})
+
+ if len(prov.setRec) != 1 {
+ t.Fatalf("SetDirRecursive calls = %d, want 1", len(prov.setRec))
+ }
+ if prov.setRec[0].dir != "/Music" || prov.setRec[0].recursive {
+ t.Fatalf("toggle call = %+v, want /Music recursive=false", prov.setRec[0])
+ }
+ if m.plManager.dirs[0].Recursive {
+ t.Fatalf("dir in manager state should now be flat, got %+v", m.plManager.dirs[0])
+ }
+}
+
+func TestPlMgrDirsRemoveConfirmFlow(t *testing.T) {
+ prov := &dirSourceTestProvider{
+ dirs: []playlist.DirSource{{Path: "/Music", Recursive: true}},
+ }
+ m := newDirsScreenTestModel(prov)
+ m.handlePlaylistManagerKey(tea.KeyPressMsg{Text: "D"}) // open dirs screen
+
+ // 'd' arms the confirmation prompt; nothing removed yet.
+ m.handlePlaylistManagerKey(tea.KeyPressMsg{Text: "d"})
+ if !m.plManager.confirmDel {
+ t.Fatal("confirmDel should be armed after 'd'")
+ }
+ if len(prov.removed) != 0 {
+ t.Fatalf("removed = %v before confirm, want none", prov.removed)
+ }
+
+ // 'y' confirms and removes the highlighted source.
+ m.handlePlaylistManagerKey(tea.KeyPressMsg{Text: "y"})
+ if len(prov.removed) != 1 || prov.removed[0] != "/Music" {
+ t.Fatalf("removed = %v, want [/Music]", prov.removed)
+ }
+ if m.plManager.confirmDel {
+ t.Fatal("confirmDel should be cleared after 'y'")
+ }
+ if len(m.plManager.dirs) != 0 {
+ t.Fatalf("dirs after remove = %+v, want empty", m.plManager.dirs)
+ }
+}
+
+func TestFileBrowserDAddsDirSource(t *testing.T) {
+ prov := &dirSourceTestProvider{
+ commandsTestProvider: commandsTestProvider{name: "Local"},
+ }
+ m := newDirsScreenTestModel(prov)
+ // Reproduce the file-browser state set up by openFileBrowserForPlaylist:
+ // the current browsing dir becomes the added source when nothing is selected.
+ m.plManager.screen = plMgrScreenDirs
+ m.fileBrowser.visible = true
+ m.fileBrowser.targetPlaylist = "music"
+ m.fileBrowser.dir = "/home/me/Music"
+
+ m.handleFileBrowserKey(tea.KeyPressMsg{Text: "D"})
+
+ if m.fileBrowser.visible {
+ t.Fatal("file browser should close after adding a dir source")
+ }
+ if len(prov.added) != 1 || prov.added[0] != "/home/me/Music" {
+ t.Fatalf("added = %v, want [/home/me/Music]", prov.added)
+ }
+ if len(m.plManager.dirs) != 1 {
+ t.Fatalf("manager dirs after add = %+v, want refreshed to 1", m.plManager.dirs)
+ }
+}
+
+func TestFileBrowserDPartialFailureStillRefreshes(t *testing.T) {
+ prov := &dirSourceTestProvider{
+ commandsTestProvider: commandsTestProvider{name: "Local"},
+ failOn: map[string]error{"/d2": errors.New("boom")},
+ }
+ m := newDirsScreenTestModel(prov)
+ m.plManager.screen = plMgrScreenDirs
+ m.plManager.selPlaylist = "music"
+ m.fileBrowser.visible = true
+ m.fileBrowser.targetPlaylist = "music"
+ // Two selected directories; the second fails partway through the loop.
+ m.fileBrowser.entries = []fbEntry{
+ {name: "d1", path: "/d1", isDir: true},
+ {name: "d2", path: "/d2", isDir: true},
+ }
+ m.fileBrowser.selected = map[string]bool{"/d1": true, "/d2": true}
+
+ m.handleFileBrowserKey(tea.KeyPressMsg{Text: "D"})
+
+ // The first dir was added even though the second failed.
+ if len(prov.added) != 1 || prov.added[0] != "/d1" {
+ t.Fatalf("added = %v, want only /d1 (partial success)", prov.added)
+ }
+ // The open manager must reflect the partial addition, not the pre-add state.
+ if len(m.plManager.dirs) != 1 || m.plManager.dirs[0].Path != "/d1" {
+ t.Fatalf("manager dirs after partial failure = %+v, want [/d1]", m.plManager.dirs)
+ }
+ if !strings.Contains(m.status.text, "then failed") {
+ t.Fatalf("status = %q, want a partial-failure message", m.status.text)
+ }
+}
+
+func TestNKeyTogglesFavorite(t *testing.T) {
+ prov := &dirSourceTestProvider{
+ commandsTestProvider: commandsTestProvider{name: "Local"},
+ }
+ m := newDirsScreenTestModel(prov)
+ m.focus = focusPlaylist
+ m.loadedPlaylist = "music"
+ m.playlist = playlist.New()
+ m.playlist.Add(playlist.Track{Path: "/song.mp3", Title: "Song"})
+ m.plCursor = 0
+ m.plManager.visible = false
+ m.favSet = nil
+
+ // Toggle on.
+ m.handleKey(tea.KeyPressMsg{Text: "n"})
+ if !prov.IsFavorited("/song.mp3") {
+ t.Fatal("track should be favorited after n")
+ }
+ if m.favSet == nil {
+ t.Fatal("favSet should be populated after toggle")
+ }
+ if _, ok := m.favSet["/song.mp3"]; !ok {
+ t.Fatal("favSet should contain /song.mp3 after toggle")
+ }
+ if !strings.Contains(m.status.text, "♥") {
+ t.Fatalf("status = %q, want ♥ indicator", m.status.text)
+ }
+
+ // Toggle off.
+ m.handleKey(tea.KeyPressMsg{Text: "n"})
+ if prov.IsFavorited("/song.mp3") {
+ t.Fatal("track should be unfavorited after second n")
+ }
+ if m.favSet != nil {
+ if _, ok := m.favSet["/song.mp3"]; ok {
+ t.Fatal("favSet should not contain /song.mp3 after toggle off")
+ }
+ }
+ if !strings.Contains(m.status.text, "♡") {
+ t.Fatalf("status = %q, want ♡ indicator", m.status.text)
+ }
+}
+
+func TestNKeyNoopWithoutFavMgr(t *testing.T) {
+ plain := commandsTestProvider{name: "Local"}
+ m := newDirsScreenTestModel(&dirSourceTestProvider{})
+ m.localProvider = plain
+ m.provider = plain
+ m.favMgr = nil
+ m.focus = focusPlaylist
+ m.loadedPlaylist = "music"
+ m.playlist = playlist.New()
+ m.playlist.Add(playlist.Track{Path: "/song.mp3", Title: "Song"})
+ m.plCursor = 0
+
+ m.handleKey(tea.KeyPressMsg{Text: "n"})
+
+ // No crash, no status change.
+ if m.status.text != "" {
+ t.Fatalf("status = %q, want empty (no favMgr)", m.status.text)
+ }
+}
diff --git a/ui/model/filebrowser.go b/ui/model/filebrowser.go
index b8d521ffa..4564af191 100644
--- a/ui/model/filebrowser.go
+++ b/ui/model/filebrowser.go
@@ -463,6 +463,13 @@ func (m *Model) handleFileBrowserKey(msg tea.KeyPressMsg) tea.Cmd {
return m.fbConfirmToPlaylist()
}
}
+
+ case "D":
+ // Add the selected directory (or the current directory) as a [[dir]]
+ // source on the target playlist instead of expanding it into tracks.
+ if m.fileBrowser.targetPlaylist != "" {
+ m.fbAddDirSource()
+ }
}
// Change drive letter on Windows by pressing alt+[c..z]
diff --git a/ui/model/init.go b/ui/model/init.go
index b36f4372e..1bcddc145 100644
--- a/ui/model/init.go
+++ b/ui/model/init.go
@@ -10,6 +10,7 @@ import (
"github.com/bjarneo/cliamp/luaplugin"
"github.com/bjarneo/cliamp/player"
"github.com/bjarneo/cliamp/playlist"
+ "github.com/bjarneo/cliamp/provider"
"github.com/bjarneo/cliamp/theme"
"github.com/bjarneo/cliamp/ui"
)
@@ -43,6 +44,10 @@ func New(p player.Engine, pl *playlist.Playlist, providers []ProviderEntry, defa
historyStore: history.New(),
showAlbumHeaders: false,
}
+ if fm, ok := any(localProv).(provider.FavoritesManager); ok {
+ m.favMgr = fm
+ m.refreshFavSet()
+ }
if luaMgr != nil {
m.pluginEmit = &pluginEmitState{}
}
@@ -211,3 +216,21 @@ func (m Model) Init() tea.Cmd {
}
return tea.Batch(cmds...)
}
+
+// refreshFavSet rebuilds the in-memory set of favorited paths from the
+// favorites store. Call after every toggle and on init so the render path
+// never hits disk.
+func (m *Model) refreshFavSet() {
+ m.favSet = nil
+ if m.favMgr == nil {
+ return
+ }
+ tracks, err := m.localProvider.Tracks("Favorites")
+ if err != nil || len(tracks) == 0 {
+ return
+ }
+ m.favSet = make(map[string]struct{}, len(tracks))
+ for _, t := range tracks {
+ m.favSet[t.Path] = struct{}{}
+ }
+}
diff --git a/ui/model/keys.go b/ui/model/keys.go
index 264aaf15c..ff6dc7271 100644
--- a/ui/model/keys.go
+++ b/ui/model/keys.go
@@ -559,6 +559,25 @@ func (m *Model) handleKey(msg tea.KeyPressMsg) tea.Cmd {
}
}
+ case "n":
+ if m.focus == focusPlaylist && m.plCursor >= 0 && m.plCursor < m.playlist.Len() && m.favMgr != nil {
+ track, ok := m.playlist.Track(m.plCursor)
+ if !ok {
+ return nil
+ }
+ added, err := m.favMgr.ToggleFavorite(track)
+ if err != nil {
+ m.status.Errorf(statusTTLDefault, "Favorite failed: %s", err)
+ return nil
+ }
+ m.refreshFavSet()
+ if added {
+ m.status.Showf(statusTTLDefault, "♥ %s", track.DisplayName())
+ } else {
+ m.status.Showf(statusTTLDefault, "♡ %s", track.DisplayName())
+ }
+ }
+
case "shift+up":
if m.focus == focusPlaylist && m.plCursor > 0 {
if m.playlist.Move(m.plCursor, m.plCursor-1) {
@@ -1577,6 +1596,8 @@ func (m *Model) handlePlaylistManagerKey(msg tea.KeyPressMsg) tea.Cmd {
return m.handlePlMgrListKey(msg)
case plMgrScreenTracks:
return m.handlePlMgrTracksKey(msg)
+ case plMgrScreenDirs:
+ return m.handlePlMgrDirsKey(msg)
case plMgrScreenNewName:
return m.handlePlMgrNewNameKey(msg)
case plMgrScreenRename:
@@ -1896,6 +1917,43 @@ func (m *Model) handlePlMgrTracksKey(msg tea.KeyPressMsg) tea.Cmd {
}
case "o":
m.openFileBrowserForPlaylist(m.plManager.selPlaylist)
+ case "D":
+ m.plMgrOpenDirs()
+ case "f":
+ if bs, ok := m.localProvider.(provider.BookmarkSetter); ok {
+ realIdx := m.plMgrTrackRealIndex(m.plManager.cursor)
+ if realIdx >= 0 && realIdx < len(m.plManager.tracks) {
+ track := m.plManager.tracks[realIdx]
+ if err := bs.SetBookmarkByPath(m.plManager.selPlaylist, track.Path); err != nil {
+ m.status.Errorf(statusTTLDefault, "Save failed: %s", err)
+ return nil
+ }
+ m.plManager.tracks[realIdx].Bookmark = !m.plManager.tracks[realIdx].Bookmark
+ if m.plManager.tracks[realIdx].Bookmark {
+ m.status.Showf(statusTTLDefault, "★ %s", track.DisplayName())
+ } else {
+ m.status.Showf(statusTTLDefault, "☆ %s", track.DisplayName())
+ }
+ }
+ }
+ case "n":
+ if m.favMgr != nil {
+ realIdx := m.plMgrTrackRealIndex(m.plManager.cursor)
+ if realIdx >= 0 && realIdx < len(m.plManager.tracks) {
+ track := m.plManager.tracks[realIdx]
+ added, err := m.favMgr.ToggleFavorite(track)
+ if err != nil {
+ m.status.Errorf(statusTTLDefault, "Favorite failed: %s", err)
+ return nil
+ }
+ m.refreshFavSet()
+ if added {
+ m.status.Showf(statusTTLDefault, "♥ %s", track.DisplayName())
+ } else {
+ m.status.Showf(statusTTLDefault, "♡ %s", track.DisplayName())
+ }
+ }
+ }
case "d":
m.plMgrRemoveSelectedTracks()
case "u":
@@ -1944,6 +2002,113 @@ func (m *Model) plMgrLoadAndPlay(startIdx int) tea.Cmd {
return cmd
}
+// handlePlMgrDirsKey handles keys on the directory-sources screen. The screen
+// lists [[dir]] sources and supports add (via the file browser), remove
+// (y/n confirm), and toggle-recursive. Navigation mirrors the other screens.
+func (m *Model) handlePlMgrDirsKey(msg tea.KeyPressMsg) tea.Cmd {
+ count := len(m.plManager.dirs)
+
+ // Remove-confirmation flow takes priority once armed.
+ if m.plManager.confirmDel {
+ switch msg.String() {
+ case "y", "Y":
+ i := m.plManager.cursor
+ if i >= 0 && i < count {
+ src := m.plManager.dirs[i]
+ if dm, ok := m.localProvider.(provider.PlaylistDirSourceManager); ok {
+ if err := dm.RemoveDirSource(m.plManager.selPlaylist, src.Path); err != nil {
+ m.status.Showf(statusTTLDefault, "Remove failed: %s", err)
+ } else {
+ m.plMgrReloadDirs()
+ m.plMgrRefreshTracksForSel()
+ m.plMgrRefreshList()
+ m.status.Showf(statusTTLDefault, "Removed %q from %q", src.Path, m.plManager.selPlaylist)
+ }
+ }
+ }
+ m.plManager.confirmDel = false
+ return nil
+ default:
+ m.plManager.confirmDel = false
+ return nil
+ }
+ }
+
+ switch msg.String() {
+ case "ctrl+c":
+ m.plManager.visible = false
+ return m.quit()
+ case "up", "k":
+ if m.plManager.cursor > 0 {
+ m.plManager.cursor--
+ } else if count > 0 {
+ m.plManager.cursor = count - 1
+ }
+ m.plMgrDirsMaybeAdjustScroll(m.plMgrDirsVisible())
+ case "down", "j":
+ if m.plManager.cursor < count-1 {
+ m.plManager.cursor++
+ } else if count > 0 {
+ m.plManager.cursor = 0
+ }
+ m.plMgrDirsMaybeAdjustScroll(m.plMgrDirsVisible())
+ case "pgup", "ctrl+u":
+ if m.plManager.cursor > 0 {
+ visible := m.plMgrDirsVisible()
+ m.plManager.cursor -= min(m.plManager.cursor, visible)
+ m.plMgrDirsMaybeAdjustScroll(visible)
+ }
+ case "pgdown", "ctrl+d":
+ if m.plManager.cursor < count-1 {
+ visible := m.plMgrDirsVisible()
+ m.plManager.cursor = min(count-1, m.plManager.cursor+visible)
+ m.plMgrDirsMaybeAdjustScroll(visible)
+ }
+ case "home", "g":
+ m.plManager.cursor = 0
+ m.plMgrDirsMaybeAdjustScroll(m.plMgrDirsVisible())
+ case "end", "G":
+ if count > 0 {
+ m.plManager.cursor = count - 1
+ }
+ m.plMgrDirsMaybeAdjustScroll(m.plMgrDirsVisible())
+ case "a":
+ // Open the file browser to pick a directory; the browser's D action
+ // adds the picked directory as a [[dir]] source to this playlist.
+ m.openFileBrowserForPlaylist(m.plManager.selPlaylist)
+ return nil
+ case "d":
+ if count == 0 {
+ return nil
+ }
+ m.plManager.confirmDel = true
+ case "r":
+ if count == 0 {
+ return nil
+ }
+ src := m.plManager.dirs[m.plManager.cursor]
+ if dm, ok := m.localProvider.(provider.PlaylistDirSourceManager); ok {
+ next := !src.Recursive
+ if err := dm.SetDirRecursive(m.plManager.selPlaylist, src.Path, next); err != nil {
+ m.status.Showf(statusTTLDefault, "Toggle recursive: %s", err)
+ } else {
+ mode := "recursive"
+ if !next {
+ mode = "flat"
+ }
+ m.plMgrReloadDirs()
+ m.plMgrRefreshTracksForSel()
+ m.plMgrRefreshList()
+ m.status.Showf(statusTTLDefault, "Set %q %s", src.Path, mode)
+ }
+ }
+ case "esc", "backspace", "h", "left":
+ // Back to the tracks screen; reload tracks so dir changes are shown.
+ m.plMgrEnterTrackList(m.plManager.selPlaylist)
+ }
+ return nil
+}
+
// handlePlMgrNewNameKey handles keys on screen 2 (new playlist name input).
func (m *Model) handlePlMgrNewNameKey(msg tea.KeyPressMsg) tea.Cmd {
switch msg.Code {
diff --git a/ui/model/model.go b/ui/model/model.go
index b5f573aa3..214e7ad6f 100644
--- a/ui/model/model.go
+++ b/ui/model/model.go
@@ -9,6 +9,7 @@ import (
"github.com/bjarneo/cliamp/luaplugin"
"github.com/bjarneo/cliamp/player"
"github.com/bjarneo/cliamp/playlist"
+ "github.com/bjarneo/cliamp/provider"
"github.com/bjarneo/cliamp/theme"
"github.com/bjarneo/cliamp/ui"
)
@@ -181,6 +182,7 @@ type plMgrScreenType int
const (
plMgrScreenList plMgrScreenType = iota
plMgrScreenTracks
+ plMgrScreenDirs
plMgrScreenNewName
plMgrScreenRename
)
@@ -364,6 +366,14 @@ type Model struct {
// History recorder (nil if config dir unavailable; safe to call when nil)
historyStore *history.Store
+ // Favorites manager (nil when local provider doesn't support it; safe to
+ // call when nil). Cached here to avoid a type assertion per rendered track.
+ favMgr provider.FavoritesManager
+
+ // favSet is a cached set of favorited paths for O(1) lookup during
+ // rendering. Refreshed on init and after every toggle.
+ favSet map[string]struct{}
+
// initialDir is the starting path for the file browser ('o' key).
initialDir string
diff --git a/ui/model/overlays.go b/ui/model/overlays.go
index 45d3ac4b3..3fbae2925 100644
--- a/ui/model/overlays.go
+++ b/ui/model/overlays.go
@@ -5,7 +5,9 @@ import (
"os"
"strings"
+ "github.com/bjarneo/cliamp/history"
"github.com/bjarneo/cliamp/playlist"
+ "github.com/bjarneo/cliamp/provider"
"github.com/bjarneo/cliamp/theme"
"github.com/bjarneo/cliamp/ui"
)
@@ -333,6 +335,18 @@ func (m *Model) plMgrTracksHelpLine() string {
return m.commandHelp(commandModePlaylistManager)
}
+func (m *Model) plMgrDirsHelpLine() string {
+ return m.commandHelp(commandModePlaylistManagerDirs)
+}
+
+func (m *Model) plMgrDirsVisible() int {
+ return m.effectivePlaylistVisible()
+}
+
+func (m *Model) plMgrDirsMaybeAdjustScroll(visible int) {
+ clampScroll(&m.plManager.cursor, &m.plManager.scroll, len(m.plManager.dirs), visible)
+}
+
func (m *Model) plMgrTracksVisible() int {
return m.effectivePlaylistVisible()
}
@@ -425,6 +439,142 @@ func missingLocalTrack(track playlist.Track) bool {
return os.IsNotExist(err)
}
+// plMgrOpenDirs loads the [[dir]] sources for the open playlist and switches
+// to the directory-sources screen. Playlists whose provider does not implement
+// provider.PlaylistDirSourceManager show a notice instead of switching.
+func (m *Model) plMgrOpenDirs() {
+ if m.plManager.selPlaylist == history.PlaylistName {
+ m.status.Showf(statusTTLDefault, "%q is a virtual playlist with no directory sources", m.plManager.selPlaylist)
+ return
+ }
+ dm, ok := m.localProvider.(provider.PlaylistDirSourceManager)
+ if !ok {
+ m.status.Showf(statusTTLDefault, "%q does not support directory sources", m.plManager.selPlaylist)
+ return
+ }
+ dirs, err := dm.DirSources(m.plManager.selPlaylist)
+ if err != nil {
+ m.status.Showf(statusTTLDefault, "Load dir sources: %s", err)
+ return
+ }
+ m.plManager.dirs = dirs
+ m.plManager.screen = plMgrScreenDirs
+ m.plManager.cursor = 0
+ m.plManager.scroll = 0
+ m.plManager.confirmDel = false
+ m.plMgrResetFilter()
+ m.plMgrDirsMaybeAdjustScroll(m.plMgrDirsVisible())
+}
+
+// plMgrReloadDirs re-reads the [[dir]] sources for the open playlist and
+// clamps the cursor so it stays valid after an add or remove.
+func (m *Model) plMgrReloadDirs() {
+ dm, ok := m.localProvider.(provider.PlaylistDirSourceManager)
+ if !ok {
+ return
+ }
+ dirs, err := dm.DirSources(m.plManager.selPlaylist)
+ if err != nil {
+ m.status.Showf(statusTTLDefault, "Reload dir sources: %s", err)
+ return
+ }
+ m.plManager.dirs = dirs
+ if m.plManager.cursor >= len(dirs) {
+ m.plManager.cursor = len(dirs) - 1
+ }
+ if m.plManager.cursor < 0 {
+ m.plManager.cursor = 0
+ }
+ m.plMgrDirsMaybeAdjustScroll(m.plMgrDirsVisible())
+}
+
+// plMgrRefreshTracksForSel reloads the tracks of the open playlist so changes
+// to its [[dir]] sources (add/remove/toggle-recursive) are reflected in the
+// tracks screen immediately.
+func (m *Model) plMgrRefreshTracksForSel() {
+ tracks, err := m.localProvider.Tracks(m.plManager.selPlaylist)
+ if err != nil {
+ return
+ }
+ // plMgrLoadTracks keeps the missingLocal cache in sync with the new
+ // track slice; assigning tracks directly would leave stale per-track
+ // missing-file indicators mapped onto the wrong entries.
+ m.plMgrLoadTracks(tracks)
+ m.setHeaderStateFromTracks(tracks)
+}
+
+// fbAddDirSource adds the file browser's selected directories (or the current
+// browsing directory when none are selected) as [[dir]] sources on the target
+// playlist, then closes the browser. Invoked by the file browser's D key when
+// a target playlist is set.
+func (m *Model) fbAddDirSource() {
+ target := m.fileBrowser.targetPlaylist
+ if target == "" || target == history.PlaylistName {
+ if target == history.PlaylistName {
+ m.status.Showf(statusTTLDefault, "%q is a virtual playlist with no directory sources", target)
+ }
+ return
+ }
+ dm, ok := m.localProvider.(provider.PlaylistDirSourceManager)
+ if !ok {
+ m.status.Showf(statusTTLDefault, "This provider does not support directory sources")
+ return
+ }
+ var dirs []string
+ for _, e := range m.fileBrowser.entries {
+ if m.fileBrowser.selected[e.path] && e.isDir && !e.isParent {
+ dirs = append(dirs, e.path)
+ }
+ }
+ if len(dirs) == 0 {
+ dirs = []string{m.fileBrowser.dir}
+ }
+ added, skipped := 0, 0
+ var firstErr error
+ for _, d := range dirs {
+ a, err := dm.AddDirSource(target, d)
+ if err != nil {
+ firstErr = err
+ break
+ }
+ if a {
+ added++
+ } else {
+ skipped++
+ }
+ }
+ m.fileBrowser.visible = false
+ // Reflect any successful additions in an open manager screen for this
+ // playlist before reporting a partial failure, so the open screen never
+ // shows stale sources or counts after an AddDirSource error mid-loop.
+ if added > 0 && m.plManager.visible && m.plManager.selPlaylist == target {
+ switch m.plManager.screen {
+ case plMgrScreenDirs:
+ m.plMgrReloadDirs()
+ m.plMgrRefreshTracksForSel()
+ case plMgrScreenTracks:
+ m.plMgrRefreshTracksForSel()
+ }
+ m.plMgrRefreshList()
+ }
+ if firstErr != nil {
+ if added > 0 {
+ m.status.Showf(statusTTLDefault, "Added %d dir source(s) to %q; then failed: %s", added, target, firstErr)
+ } else {
+ m.status.Showf(statusTTLDefault, "Add dir source failed: %s", firstErr)
+ }
+ return
+ }
+ switch {
+ case added > 0 && skipped > 0:
+ m.status.Showf(statusTTLDefault, "Added %d dir source(s) to %q (%d already referenced)", added, target, skipped)
+ case added > 0:
+ m.status.Showf(statusTTLDefault, "Added %d dir source(s) to %q", added, target)
+ default:
+ m.status.Showf(statusTTLDefault, "%q already references that directory", target)
+ }
+}
+
// plMgrResetFilter clears any active `/` filter on the playlist manager.
func (m *Model) plMgrResetFilter() {
m.plManager.filtering = false
@@ -508,14 +658,19 @@ func (m *Model) plMgrRefreshList() {
if m.plManager.filter != "" {
m.plMgrRecomputeFilter()
}
- total := m.plMgrListViewCount()
- if m.plManager.cursor >= total {
- m.plManager.cursor = total - 1
- }
- if m.plManager.cursor < 0 {
- m.plManager.cursor = 0
+ // Cursor/scroll clamping is list-screen-specific: the tracks and
+ // directory-sources screens own their own cursor and re-adjust after
+ // refreshing. Only the list screen re-clamps here.
+ if m.plManager.screen == plMgrScreenList {
+ total := m.plMgrListViewCount()
+ if m.plManager.cursor >= total {
+ m.plManager.cursor = total - 1
+ }
+ if m.plManager.cursor < 0 {
+ m.plManager.cursor = 0
+ }
+ m.plMgrListMaybeAdjustScroll(m.plMgrListVisible())
}
- m.plMgrListMaybeAdjustScroll(m.plMgrListVisible())
}
// plMgrListViewCount returns the visible row count on the list screen
diff --git a/ui/model/scroll.go b/ui/model/scroll.go
index 97f15fb10..2d0a6b95e 100644
--- a/ui/model/scroll.go
+++ b/ui/model/scroll.go
@@ -140,6 +140,8 @@ func (m *Model) clampActiveScrollState() {
m.plMgrListMaybeAdjustScroll(m.plMgrListVisible())
} else if m.plManager.screen == plMgrScreenTracks {
m.plMgrTracksMaybeAdjustScroll(m.plMgrTracksVisible())
+ } else if m.plManager.screen == plMgrScreenDirs {
+ m.plMgrDirsMaybeAdjustScroll(m.plMgrDirsVisible())
}
case screenSpotSearch:
if m.spotSearch.screen == spotSearchResults {
diff --git a/ui/model/state.go b/ui/model/state.go
index 6ff3a0a1f..fe793b824 100644
--- a/ui/model/state.go
+++ b/ui/model/state.go
@@ -137,9 +137,10 @@ type plManagerState struct {
cursor int // view-index: offset into filtered when filter != "", else direct index
scroll int
playlists []playlist.PlaylistInfo
- selPlaylist string // playlist name open in screen 1
- tracks []playlist.Track // tracks in the selected playlist
- missingLocal []bool // cached missing-file state, indexed with tracks
+ selPlaylist string // playlist name open in screen 1
+ tracks []playlist.Track // tracks in the selected playlist
+ missingLocal []bool // cached missing-file state, indexed with tracks
+ dirs []playlist.DirSource // [[dir]] sources for the selected playlist (screen 2)
newName string
confirmDel bool
renameOldName string
diff --git a/ui/model/view.go b/ui/model/view.go
index 7066bd5c3..657780e10 100644
--- a/ui/model/view.go
+++ b/ui/model/view.go
@@ -97,13 +97,10 @@ func (m Model) isProviderRowActive(p playlist.PlaylistInfo) bool {
// supply. Track count and total duration are appended when available.
func playlistLabel(prefix string, p playlist.PlaylistInfo) string {
out := prefix + p.Name
- parts := make([]string, 0, 2)
+ var parts []string
if p.TrackCount > 0 {
parts = append(parts, fmt.Sprintf("%d tracks", p.TrackCount))
}
- if d := formatPlaylistDuration(p.DurationSecs); d != "" {
- parts = append(parts, d)
- }
if len(parts) > 0 {
out += " · " + strings.Join(parts, " · ")
}
@@ -621,6 +618,13 @@ func (m Model) renderPlaylistHeader() string {
bookmarkStr = " " + activeToggle.Render(fmt.Sprintf("[★ %d]", bookmarkCount))
}
+ var favStr string
+ if m.favMgr != nil {
+ if count := m.favMgr.FavoritesCount(); count > 0 {
+ favStr = " " + activeToggle.Render(fmt.Sprintf("[♥ %d]", count))
+ }
+ }
+
var themeStr string
if name := m.ThemeName(); name != theme.DefaultName {
themeStr = " " + activeToggle.Render("[Theme: "+name+"]")
@@ -637,7 +641,7 @@ func (m Model) renderPlaylistHeader() string {
headerStyle = activeToggle
headerLabel = "▸─ Playlist ── "
}
- return headerStyle.Render(headerLabel) + shuffle + queueStr + bookmarkStr + posStr + themeStr + " " + dimStyle.Render("──")
+ return headerStyle.Render(headerLabel) + shuffle + queueStr + bookmarkStr + favStr + posStr + themeStr + " " + dimStyle.Render("──")
}
func (m Model) renderProviderList() string {
@@ -848,11 +852,17 @@ func (m Model) renderPlaylist() string {
if t.Bookmark {
bookmarkMarker = "★"
}
+ favMarker := " "
+ if m.favSet != nil {
+ if _, ok := m.favSet[t.Path]; ok {
+ favMarker = "♥"
+ }
+ }
unavailableMarker := " "
if t.Unplayable {
unavailableMarker = "!"
}
- markers := cursorMarker + playingMarker + queueMarker + bookmarkMarker + unavailableMarker + " "
+ markers := cursorMarker + playingMarker + queueMarker + bookmarkMarker + favMarker + unavailableMarker + " "
name := t.DisplayName()
queueSuffix := ""
@@ -889,7 +899,7 @@ func (m Model) renderPlaylist() string {
numStr := fmt.Sprintf("%*d. ", numWidth, i+1)
line := dimStyle.Render(cursorMarker) + playlistActiveStyle.Render(playingMarker) +
- activeToggle.Render(queueMarker+bookmarkMarker) + playlistUnavailableStyle.Render(unavailableMarker) +
+ activeToggle.Render(queueMarker+bookmarkMarker) + playlistUnavailableStyle.Render(favMarker+unavailableMarker) +
" " + style.Render(numStr)
line += style.Render(name)
if albumSuffix != "" {
diff --git a/ui/model/view_helpers_test.go b/ui/model/view_helpers_test.go
index 966bf7299..7dfc4876c 100644
--- a/ui/model/view_helpers_test.go
+++ b/ui/model/view_helpers_test.go
@@ -62,7 +62,7 @@ func TestPlaylistLabel(t *testing.T) {
want string
}{
{
- "name only when both unknown",
+ "name only when no tracks",
" ",
playlist.PlaylistInfo{Name: "Mix"},
" Mix",
@@ -74,16 +74,16 @@ func TestPlaylistLabel(t *testing.T) {
"> Mix · 12 tracks",
},
{
- "duration only",
+ "duration ignored",
" ",
playlist.PlaylistInfo{Name: "Mix", DurationSecs: 3660},
- " Mix · 1h 1m",
+ " Mix",
},
{
- "both",
+ "tracks and duration shows only tracks",
" ",
playlist.PlaylistInfo{Name: "Mix", TrackCount: 12, DurationSecs: 2700},
- " Mix · 12 tracks · 45m",
+ " Mix · 12 tracks",
},
}
for _, tt := range tests {
diff --git a/ui/model/view_overlays.go b/ui/model/view_overlays.go
index 3ad1045a2..5a16a036e 100644
--- a/ui/model/view_overlays.go
+++ b/ui/model/view_overlays.go
@@ -59,6 +59,9 @@ func (m Model) plMgrHeaderLine() string {
label += " · sort: " + mode
}
return sepHeaderN(label, m.plManager.cursor+1, len(m.plManager.tracks))
+ case plMgrScreenDirs:
+ label := "Directory sources: " + m.plManager.selPlaylist
+ return sepHeaderN(label, m.plManager.cursor+1, len(m.plManager.dirs))
case plMgrScreenNewName:
return m.promptHeader("playlist-manager-new-name", "New Playlist", m.plManager.newName)
case plMgrScreenRename:
@@ -76,6 +79,8 @@ func (m Model) plMgrHelpLine() string {
switch m.plManager.screen {
case plMgrScreenTracks:
return m.plMgrTracksHelpLine()
+ case plMgrScreenDirs:
+ return m.plMgrDirsHelpLine()
case plMgrScreenNewName:
return m.commandHelp(commandModePlaylistManagerInput)
case plMgrScreenRename:
@@ -89,6 +94,8 @@ func (m Model) renderPlMgrBody() string {
switch m.plManager.screen {
case plMgrScreenTracks:
return m.renderPlMgrTracksBody()
+ case plMgrScreenDirs:
+ return m.renderPlMgrDirsBody()
case plMgrScreenNewName, plMgrScreenRename:
return m.renderPlMgrFormBody()
default:
@@ -250,6 +257,36 @@ func (m Model) renderPlMgrTracksBody() string {
return bodyLines(lines, budget)
}
+// renderPlMgrDirsBody renders the [[dir]] directory sources for the open
+// playlist. Each row shows the source path and its scan mode (recursive or
+// flat). An empty list shows how to add a source.
+func (m Model) renderPlMgrDirsBody() string {
+ budget := m.effectivePlaylistVisible()
+
+ if len(m.plManager.dirs) == 0 {
+ return bodyLines([]string{
+ dimStyle.Render(" No directory sources."),
+ dimStyle.Render(" Press `a` to pick a directory to scan."),
+ }, budget)
+ }
+
+ scroll := m.plManager.scroll
+ lines := make([]string, 0, budget)
+ for i := scroll; i < len(m.plManager.dirs) && len(lines) < budget; i++ {
+ src := m.plManager.dirs[i]
+ mode := "recursive"
+ if !src.Recursive {
+ mode = "flat"
+ }
+ if m.plManager.confirmDel && i == m.plManager.cursor {
+ lines = append(lines, playlistSelectedStyle.Render("> Remove "+src.Path+"? [y/n]"))
+ continue
+ }
+ lines = append(lines, cursorLine(src.Path+" · "+mode, i == m.plManager.cursor))
+ }
+ return bodyLines(lines, budget)
+}
+
func (m Model) plMgrTrackLabel(realIdx int) string {
t := m.plManager.tracks[realIdx]
mark := " "