Add alternative names and cover art for soundtracks

Alternative names (#32):
- PUT /api/v1/soundtracks/{uuid}/alternative-names replaces a soundtrack's
  alternative names (trimmed, deduplicated, without the soundtrack's own name).
- alternative_names is in the soundtrack and statistics responses.
- /find matches them too and shows which name matched.

Covers (#12), stored in COVERS_PATH and off when it is not set:
- GET, PUT (upload) and DELETE /api/v1/soundtracks/{uuid}/cover, and
  PUT .../cover/source to pick a SteamGridDB game or AniList anime by ID.
  Uploaded and picked covers are never replaced automatically.
- With STEAMGRIDDB_API_KEY, a background job searches SteamGridDB, then
  AniList, by name, alternative names and the name without bracketed parts,
  at startup, after a sync and after names change. Search results are ranked
  by matching words, so "Civilization IV" gets "Sid Meier's Civilization IV".
- cover_modified (Unix seconds) is in the soundtrack and statistics responses,
  so clients can cache covers.

The new columns are added to migration 000006, which is not released yet.

Closes #12, closes #32

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>

cmd/web/assets/css/styles.css

@@ -135,6 +135,12 @@ main {
     margin-top: 1.5rem;
 }
 
+.matched-name {
+    margin: 0.25rem 0 0;
+    font-size: 0.9rem;
+    color: var(--text-secondary);
+}
+
 /* Responsive adjustments */
 @media (max-width: 768px) {
     #search_term {

cmd/web/search.go

@@ -33,15 +33,33 @@ func NewSearchHandler(cache *backend.SearchCache) http.Handler {
 	})
 }
 
+// SearchResult is a soundtrack found by search. MatchedName is the alternative name that
+// matched, or empty when the soundtrack's own name matched.
+type SearchResult struct {
+	Name        string
+	MatchedName string
+}
+
 // search returns the soundtracks matching searchText: exact matches first, then matches
-// ignoring spaces and special characters, then matches with the letters in order.
-func search(searchText string, soundtrackData []backend.SoundtrackData) []string {
-	var results []string
+// ignoring spaces and special characters, then matches with the letters in order. Each
+// step tries the soundtrack's own name before its alternative names.
+func search(searchText string, soundtrackData []backend.SoundtrackData) []SearchResult {
+	var results []SearchResult
 	seen := make(map[string]bool)
-	add := func(match func(backend.SoundtrackData) bool) {
+	add := func(match func(backend.SearchName) bool) {
 		for _, data := range soundtrackData {
-			if !seen[data.Original] && match(data) {
-				results = append(results, data.Original)
+			if seen[data.Original] {
+				continue
+			}
+			matched, ok := "", match(data.SearchName)
+			for _, alternative := range data.Alternatives {
+				if ok {
+					break
+				}
+				matched, ok = alternative.Original, match(alternative)
+			}
+			if ok {
+				results = append(results, SearchResult{Name: data.Original, MatchedName: matched})
 				seen[data.Original] = true
 			}
 		}
@@ -50,8 +68,8 @@ func search(searchText string, soundtrackData []backend.SoundtrackData) []string
 	lowercase := strings.ToLower(searchText)
 	cleaned := backend.CleanSearchTerm(searchText)
 
-	add(func(d backend.SoundtrackData) bool { return strings.Contains(d.Lowercase, lowercase) })
-	add(func(d backend.SoundtrackData) bool { return strings.Contains(d.Cleaned, cleaned) })
-	add(func(d backend.SoundtrackData) bool { return backend.MatchesSubsequence(cleaned, d.Cleaned) })
+	add(func(n backend.SearchName) bool { return strings.Contains(n.Lowercase, lowercase) })
+	add(func(n backend.SearchName) bool { return strings.Contains(n.Cleaned, cleaned) })
+	add(func(n backend.SearchName) bool { return backend.MatchesSubsequence(cleaned, n.Cleaned) })
 	return results
 }

cmd/web/search.templ

@@ -40,10 +40,13 @@ templ SearchForm() {
 	}
 }
 
-templ FoundSoundtracks(soundtracks []string) {
+templ FoundSoundtracks(soundtracks []SearchResult) {
 	for _, soundtrack := range soundtracks {
 		<div class="bg-green-100 p-4 shadow-md rounded-lg mt-6">
-			<p class="soundtrack-text">{ soundtrack }</p>
+			<p class="soundtrack-text">{ soundtrack.Name }</p>
+			if soundtrack.MatchedName != "" {
+				<p class="matched-name">Also known as { soundtrack.MatchedName }</p>
+			}
 		</div>
 	}
 }

cmd/web/search_test.go

@@ -28,8 +28,24 @@ var soundtracks = []string{
 	"Ys III - Wanderers from Ys (+The Oath in Felghana)",
 }
 
-func newCache(names []string) *backend.SearchCache {
-	return backend.NewSearchCache(func(context.Context) ([]string, error) { return names, nil })
+func newCache(names []string, alternatives ...map[string][]string) *backend.SearchCache {
+	soundtracks := make([]backend.SearchSoundtrack, len(names))
+	for i, name := range names {
+		soundtracks[i] = backend.SearchSoundtrack{Name: name}
+		for _, a := range alternatives {
+			soundtracks[i].AlternativeNames = a[name]
+		}
+	}
+	return backend.NewSearchCache(func(context.Context) ([]backend.SearchSoundtrack, error) { return soundtracks, nil })
+}
+
+// names returns the soundtrack names of results.
+func names(results []SearchResult) []string {
+	var n []string
+	for _, r := range results {
+		n = append(n, r.Name)
+	}
+	return n
 }
 
 func searchData(t *testing.T) []backend.SoundtrackData {
@@ -62,23 +78,50 @@ func TestSearch(t *testing.T) {
 	}
 	for _, tt := range tests {
 		t.Run(tt.query, func(t *testing.T) {
-			assert.Equal(t, tt.want, search(tt.query, data))
+			assert.Equal(t, tt.want, names(search(tt.query, data)))
 		})
 	}
 }
 
 func TestSearchEmptyReturnsEverything(t *testing.T) {
-	assert.Equal(t, soundtracks, search("", searchData(t)))
+	assert.Equal(t, soundtracks, names(search("", searchData(t))))
 }
 
 func TestSearchOrdering(t *testing.T) {
 	// "MG" is an exact match, "Metal Gear Solid..." only matches by letters in order.
-	results := search("mg", searchData(t))
+	results := names(search("mg", searchData(t)))
 	require.GreaterOrEqual(t, len(results), 2)
 	assert.Equal(t, "MG", results[0])
 	assert.Contains(t, results, "Metal Gear Solid 4 - Guns of the Patriots")
 }
 
+func TestSearchAlternativeNames(t *testing.T) {
+	data, err := newCache(soundtracks, map[string][]string{
+		"Final Fantasy VII": {"FF7", "ファイナルファンタジーVII"},
+		"Kingdom Hearts":    {"KH"},
+	}).Get(context.Background())
+	require.NoError(t, err)
+
+	assert.Equal(t, []SearchResult{{Name: "Final Fantasy VII", MatchedName: "FF7"}}, search("ff7", data))
+	assert.Equal(t, []SearchResult{{Name: "Final Fantasy VII", MatchedName: "ファイナルファンタジーVII"}}, search("ファイナル", data))
+	assert.Equal(t, []SearchResult{{Name: "Final Fantasy VII"}}, search("fantasy", data),
+		"no matched name when the soundtrack's own name matches")
+	// An exact match on an alternative name comes before a letters-in-order match on a name.
+	results := search("kh", data)
+	require.NotEmpty(t, results)
+	assert.Equal(t, SearchResult{Name: "Kingdom Hearts", MatchedName: "KH"}, results[0])
+}
+
+func TestFoundSoundtracksShowsMatchedName(t *testing.T) {
+	var out strings.Builder
+	require.NoError(t, FoundSoundtracks([]SearchResult{
+		{Name: "Final Fantasy VII", MatchedName: "FF7"}, {Name: "Kingdom Hearts"},
+	}).Render(context.Background(), &out))
+	assert.Contains(t, out.String(), "Final Fantasy VII")
+	assert.Contains(t, out.String(), "Also known as FF7")
+	assert.Equal(t, 1, strings.Count(out.String(), "Also known as"))
+}
+
 func TestSearchHandler(t *testing.T) {
 	handler := NewSearchHandler(newCache(soundtracks))
 	req := httptest.NewRequest(http.MethodPost, "/find", strings.NewReader(url.Values{"search_term": {"kingdom"}}.Encode()))
@@ -93,7 +136,7 @@ func TestSearchHandler(t *testing.T) {
 }
 
 func TestSearchHandlerLoadError(t *testing.T) {
-	cache := backend.NewSearchCache(func(context.Context) ([]string, error) { return nil, errors.New("db down") })
+	cache := backend.NewSearchCache(func(context.Context) ([]backend.SearchSoundtrack, error) { return nil, errors.New("db down") })
 	rec := httptest.NewRecorder()
 	NewSearchHandler(cache).ServeHTTP(rec, httptest.NewRequest(http.MethodPost, "/find", nil))
 	assert.Equal(t, http.StatusInternalServerError, rec.Code)