Add UPnP library search with local indexing (#22)

* Add UPnP library search with local indexing

- Add GetAllServerTracks() for recursive UPnP server scanning
- Add track index system with JSON cache persistence
- Add fuzzy search on title/artist/album fields
- Add 'upnp search <query>' command with interactive picker
- Add 'upnp index' command to view/rebuild index
- Add 'config upnp index container' to set default container path
- Add container path navigation and tab completion
- Add HTTP timeout option for large library scanning
- Fix cache status to show correct entries and size
- Add 24-hour auto-refresh for stale indexes

* Add `upnp search` and `upnp index` to make search go fast

* Add v0.2.2 changelog for UPnP search feature

Author: hilli

CHANGELOG.md

@@ -7,6 +7,33 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 ## [Unreleased]
 
+## [0.2.2] - 2025-02-03
+
+### Added
+
+- **UPnP Library Search**: New local search index for instant track searching
+  - `upnp search [query]` - Search by title, artist, or album
+  - `upnp search` (no query) - Browse full library with interactive filter
+  - `upnp index` - View index status
+  - `upnp index --rebuild` - Rebuild the search index
+  - `upnp index --container "path"` - Index from specific folder
+  - `config upnp index container` - Set default container for indexing
+  - Ranked search results with exact matches first
+  - Multi-word queries work across fields (e.g., `public enemy uzi`)
+
+- **Content Picker Improvements**
+  - Page Up/Page Down navigation for faster scrolling
+  - Filter now matches on artist/album in addition to title
+
+### Changed
+
+- `upnp play` now recursively scans sub-containers (plays all albums under an artist)
+- `upnp search` accepts multiple arguments without quotes
+
+### Fixed
+
+- Fixed `cache status` to show correct cache file and entry count
+
 ## [0.2.1] - 2026-02-02
 
 ### Added
@@ -331,7 +358,8 @@ Implemented by: `Source`, `SpeakerStatus`, `CableMode`
 
 7. **Update player ID field access**: If you access `playId.SystemMemberId`, change it to `playId.SystemMemberID`.
 
-[Unreleased]: https://github.com/hilli/go-kef-w2/compare/v0.2.1...HEAD
+[Unreleased]: https://github.com/hilli/go-kef-w2/compare/v0.2.2...HEAD
+[0.2.2]: https://github.com/hilli/go-kef-w2/compare/v0.2.1...v0.2.2
 [0.2.1]: https://github.com/hilli/go-kef-w2/compare/v0.2.0...v0.2.1
 [0.2.0]: https://github.com/hilli/go-kef-w2/compare/v0.1.0...v0.2.0
 [0.1.0]: https://github.com/hilli/go-kef-w2/releases/tag/v0.1.0

README.md

@@ -190,16 +190,60 @@ kefw2 podcast browse
 Play music from local network media servers:
 
 ```shell
-# Browse a server (with tab completion)
-kefw2 upnp browse "My NAS/Music/Albums"
+# Configure default UPnP server
+kefw2 config upnp server default "Plex Media Server: homesrv"
+
+# Browse a server interactively
+kefw2 upnp browse
+
+# Browse a specific path (with tab completion)
+kefw2 upnp browse "Music/Albums"
 
 # Play media from server
-kefw2 upnp play "My NAS/Music/Jazz/Album/Track.flac"
+kefw2 upnp play "Music/Jazz/Album/Track.flac"
+```
 
-# Configure default UPnP server
-kefw2 config upnp server "My NAS"
+#### UPnP Search
+
+Search your entire music library instantly with a local index:
+
+```shell
+# Search for tracks by title, artist, or album
+kefw2 upnp search "beatles"
+kefw2 upnp search "abbey road"
+kefw2 upnp search "come together beatles"
+
+# Add search result to queue instead of playing
+kefw2 upnp search -q "bohemian"
+```
+
+The search feature builds a local index of your UPnP music library for instant results.
+The index is cached and automatically refreshes after 24 hours.
+
+#### Index Configuration
+
+For large libraries (like Plex), you can configure which folder to index to avoid
+scanning duplicate views (By Genre, By Album, etc. contain the same tracks):
+
+```shell
+# Set the container path to index (with tab completion)
+kefw2 config upnp index container "Music/Hilli's Music/By Folder"
+
+# Show current index status
+kefw2 upnp index
+
+# Rebuild the index (uses configured container automatically)
+kefw2 upnp index --rebuild
+
+# Override container for a one-time rebuild
+kefw2 upnp index --rebuild --container "Music/My Library/By Album"
+
+# Clear the container setting (index entire server)
+kefw2 config upnp index container ""
 ```
 
+The container path uses `/` as separator and supports tab completion at each level.
+
 ### Queue Management
 
 Manage the playback queue:
@@ -296,6 +340,7 @@ kefw2 events --json
 - [x] Play Podcasts
 - [x] Play from UPnP/DLNA media servers
 - [x] Queue management
+- [x] UPnP library search with local indexing
 - [ ] Restore speaker settings/eq profiles from file
 - [ ] Play titles from built-in music streaming services (Amazon Music, Deezer, Qobuz, Spotify, Tidal)
 

cmd/kefw2/cmd/cache.go

@@ -350,28 +350,92 @@ var cacheStatusCmd = &cobra.Command{
 	Use:   "status",
 	Short: "Show cache statistics",
 	Run: func(cmd *cobra.Command, args []string) {
-		if browseCache == nil {
-			errorPrinter.Println("Cache not initialized")
-			return
+		// Get cache directory
+		cacheDir, err := os.UserCacheDir()
+		if err != nil {
+			cacheDir = os.TempDir()
+		}
+		cacheDir = filepath.Join(cacheDir, "kefw2")
+
+		headerPrinter.Println("API Response Cache:")
+		rowsCachePath := filepath.Join(cacheDir, "rows_cache.json")
+		if info, err := os.Stat(rowsCachePath); err == nil {
+			// Read and parse the cache file to count entries
+			data, readErr := os.ReadFile(rowsCachePath)
+			var entryCount int
+			var oldestAge time.Duration
+			if readErr == nil {
+				var entries map[string]json.RawMessage
+				if json.Unmarshal(data, &entries) == nil {
+					entryCount = len(entries)
+					// Try to find oldest entry
+					type entryWithTime struct {
+						FetchedAt time.Time `json:"fetched_at"`
+					}
+					var oldest time.Time
+					for _, raw := range entries {
+						var e entryWithTime
+						if json.Unmarshal(raw, &e) == nil && !e.FetchedAt.IsZero() {
+							if oldest.IsZero() || e.FetchedAt.Before(oldest) {
+								oldest = e.FetchedAt
+							}
+						}
+					}
+					if !oldest.IsZero() {
+						oldestAge = time.Since(oldest)
+					}
+				}
+			}
+			contentPrinter.Printf("  Location: %s\n", rowsCachePath)
+			contentPrinter.Printf("  Entries: %d\n", entryCount)
+			contentPrinter.Printf("  Size: %s\n", formatBytes(info.Size()))
+			if oldestAge > 0 {
+				contentPrinter.Printf("  Oldest: %v ago\n", oldestAge.Round(time.Second))
+			}
+		} else {
+			contentPrinter.Println("  No cache file found")
 		}
 
-		entries, size, oldest := browseCache.Status()
+		// Show TTL settings from config
+		if browseCache != nil {
+			contentPrinter.Println("\n  TTL Settings:")
+			contentPrinter.Printf("    Radio: %v\n", browseCache.GetTTL("radio"))
+			contentPrinter.Printf("    Podcast: %v\n", browseCache.GetTTL("podcast"))
+			contentPrinter.Printf("    UPnP: %v\n", browseCache.GetTTL("upnp"))
+		}
 
-		headerPrinter.Println("Cache Status:")
-		contentPrinter.Printf("  Enabled: %v\n", browseCache.IsEnabled())
-		contentPrinter.Printf("  Location: %s\n", browseCache.CacheDir())
-		contentPrinter.Printf("  Entries: %d\n", entries)
-		contentPrinter.Printf("  Size: %d bytes\n", size)
-		if entries > 0 {
-			contentPrinter.Printf("  Oldest: %v ago\n", oldest.Round(time.Second))
+		// Show UPnP track index status
+		headerPrinter.Println("\nUPnP Track Index:")
+		index, err := LoadTrackIndex()
+		if err != nil || index == nil {
+			contentPrinter.Println("  No index found")
+			contentPrinter.Println("  Run 'kefw2 upnp index --rebuild' to create one")
+		} else {
+			contentPrinter.Printf("  Server: %s\n", index.ServerName)
+			if index.ContainerName != "" {
+				contentPrinter.Printf("  Container: %s\n", index.ContainerName)
+			}
+			contentPrinter.Printf("  Tracks: %d\n", index.TrackCount)
+			contentPrinter.Printf("  Age: %v\n", time.Since(index.IndexedAt).Round(time.Second))
+			contentPrinter.Printf("  Location: %s\n", getTrackIndexPath())
 		}
-		contentPrinter.Println("\nTTL Settings:")
-		contentPrinter.Printf("  Radio: %v\n", browseCache.GetTTL("radio"))
-		contentPrinter.Printf("  Podcast: %v\n", browseCache.GetTTL("podcast"))
-		contentPrinter.Printf("  UPnP: %v\n", browseCache.GetTTL("upnp"))
 	},
 }
 
+// formatBytes formats bytes as human-readable string
+func formatBytes(bytes int64) string {
+	const unit = 1024
+	if bytes < unit {
+		return fmt.Sprintf("%d bytes", bytes)
+	}
+	div, exp := int64(unit), 0
+	for n := bytes / unit; n >= unit; n /= unit {
+		div *= unit
+		exp++
+	}
+	return fmt.Sprintf("%.1f %cB", float64(bytes)/float64(div), "KMGTPE"[exp])
+}
+
 func init() {
 	rootCmd.AddCommand(cacheCmd)
 	cacheCmd.AddCommand(cacheClearCmd)

cmd/kefw2/cmd/config_upnp.go

@@ -152,9 +152,139 @@ func UPnPServerCompletion(cmd *cobra.Command, args []string, toComplete string)
 	return completions, cobra.ShellCompDirectiveNoFileComp
 }
 
+// upnpIndexConfigCmd is the parent for index config subcommands
+var upnpIndexConfigCmd = &cobra.Command{
+	Use:   "index",
+	Short: "Configure UPnP search index settings",
+	Long:  `Configure settings for the UPnP search index, including the container path to index.`,
+	Run: func(cmd *cobra.Command, args []string) {
+		_ = cmd.Help()
+	},
+}
+
+// upnpIndexContainerCmd shows or sets the index container path
+var upnpIndexContainerCmd = &cobra.Command{
+	Use:   "container [path]",
+	Short: "Show or set the container path for indexing",
+	Long: `Show the current container path for indexing, or set a new one.
+
+The container path determines which folder to start indexing from.
+Use "/" as separator for nested paths.
+
+Without arguments, displays the current setting.
+With a path, sets that as the default container to index.
+
+Examples:
+  kefw2 config upnp index container                                  # Show current
+  kefw2 config upnp index container "Music"                          # Index Music folder
+  kefw2 config upnp index container "Music/Hilli's Music/By Folder"  # Index specific folder
+  kefw2 config upnp index container ""                               # Clear (index entire server)`,
+	Run: func(cmd *cobra.Command, args []string) {
+		if len(args) == 0 {
+			// Show current setting
+			containerPath := viper.GetString("upnp.index_container")
+			if containerPath == "" {
+				contentPrinter.Println("No index container configured (will index entire server).")
+				contentPrinter.Println("Use 'kefw2 config upnp index container <path>' to set one.")
+				return
+			}
+			headerPrinter.Print("Index container: ")
+			contentPrinter.Println(containerPath)
+			return
+		}
+
+		// Set new container path
+		containerPath := args[0]
+
+		// If a path is provided, validate it exists
+		if containerPath != "" {
+			serverPath := viper.GetString("upnp.default_server_path")
+			if serverPath == "" {
+				exitWithError("No default UPnP server configured. Set one first with: kefw2 config upnp server default <name>")
+			}
+
+			client := kefw2.NewAirableClient(currentSpeaker)
+			_, resolvedPath, err := findContainerByPath(client, serverPath, containerPath)
+			if err != nil {
+				exitWithError("Invalid container path: %v", err)
+			}
+			// Use the resolved path (with proper casing)
+			containerPath = resolvedPath
+		}
+
+		// Save to config
+		viper.Set("upnp.index_container", containerPath)
+		err := viper.WriteConfig()
+		exitOnError(err, "Error saving config")
+
+		if containerPath == "" {
+			taskConpletedPrinter.Println("Index container cleared (will index entire server)")
+		} else {
+			taskConpletedPrinter.Print("Index container set: ")
+			contentPrinter.Println(containerPath)
+		}
+	},
+	ValidArgsFunction: UPnPContainerCompletion,
+}
+
+// UPnPContainerCompletion provides tab completion for container paths
+func UPnPContainerCompletion(cmd *cobra.Command, args []string, toComplete string) ([]string, cobra.ShellCompDirective) {
+	if len(args) > 0 {
+		return nil, cobra.ShellCompDirectiveNoFileComp
+	}
+
+	if currentSpeaker == nil || currentSpeaker.IPAddress == "" {
+		return nil, cobra.ShellCompDirectiveNoFileComp
+	}
+
+	serverPath := viper.GetString("upnp.default_server_path")
+	if serverPath == "" {
+		return nil, cobra.ShellCompDirectiveNoFileComp
+	}
+
+	client := kefw2.NewAirableClient(currentSpeaker)
+
+	// Parse the path to complete
+	// e.g., "Music/Hilli" -> parentPath="Music", prefix="Hilli"
+	var parentPath, prefix string
+	if idx := strings.LastIndex(toComplete, "/"); idx >= 0 {
+		parentPath = toComplete[:idx]
+		prefix = toComplete[idx+1:]
+	} else {
+		parentPath = ""
+		prefix = toComplete
+	}
+
+	// Get containers at the parent path
+	containers, err := listContainersAtPath(client, serverPath, parentPath)
+	if err != nil {
+		return nil, cobra.ShellCompDirectiveNoFileComp
+	}
+
+	var completions []string
+	prefixLower := strings.ToLower(prefix)
+	for _, name := range containers {
+		if strings.HasPrefix(strings.ToLower(name), prefixLower) {
+			// Build the full path for completion
+			var fullPath string
+			if parentPath != "" {
+				fullPath = parentPath + "/" + name
+			} else {
+				fullPath = name
+			}
+			completions = append(completions, fullPath)
+		}
+	}
+
+	// Don't add space after completion (user might want to continue the path)
+	return completions, cobra.ShellCompDirectiveNoSpace | cobra.ShellCompDirectiveNoFileComp
+}
+
 func init() {
 	ConfigCmd.AddCommand(upnpConfigCmd)
 	upnpConfigCmd.AddCommand(upnpServerConfigCmd)
 	upnpServerConfigCmd.AddCommand(upnpServerDefaultCmd)
 	upnpServerConfigCmd.AddCommand(upnpServerListCmd)
+	upnpConfigCmd.AddCommand(upnpIndexConfigCmd)
+	upnpIndexConfigCmd.AddCommand(upnpIndexContainerCmd)
 }