YT Music-knapp på korten + Veckans låtar (egen låtförslags-batch)

- MusicCard: ▶ YT-knapp öppnar music.youtube.com-sökning på artist/låt/album
- Låtförslag: egen batch-typ 'tracks' — signaler: 10 senast gillade
  (Liked Music-listan i Youtubarr-DB, fallback senaste tillägg) + 10 mest
  spelade i Jellyfin (SortBy=PlayCount); egen Gemini-prompt för enskilda
  låtar; berikas med artist-MBID så Hämta lägger in artisten i Lidarr
- Upptäck: egen 'Veckans låtar'-ruta med senaste 10 + generera-knapp
- Schema: trackIntervalDays (default 7, 0 = av) i inställningarna,
  schemaläggaren kör båda typerna oberoende
- Förslag-sidan märker batcher med typ; 26 tester gröna

Co-Authored-By: Claude Fable 5 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01824ZrvG2mDYYrmwqypLNup

backend/src/suggest.js

@@ -77,6 +77,76 @@ export function suggestEngine({ config, store, lidarr, fetchImpl = fetch }) {
     return signals
   }
 
+  async function collectTrackSignals() {
+    const eff = effectiveConfig(config, store.load())
+    const signals = { gillade: [], mestSpelade: [] }
+
+    try {
+      if (existsSync(config.youtubarr.dbPath)) {
+        const db = new Database(config.youtubarr.dbPath, { readonly: true, fileMustExist: true })
+        // Gillade = Liked Music-listan (LM) om den finns, annars senaste tilläggen
+        let rows = db
+          .prepare(
+            `SELECT ti.title, ti.artist_name_guess
+             FROM youtubarr_trackitem ti
+             JOIN youtubarr_playlist p ON p.id = ti.playlist_id
+             WHERE p.playlist_id = 'LM' AND ti.blacklisted = 0
+             ORDER BY ti.id DESC LIMIT 10`,
+          )
+          .all()
+        if (rows.length === 0) {
+          rows = db
+            .prepare(
+              `SELECT ti.title, ti.artist_name_guess
+               FROM youtubarr_trackitem ti
+               WHERE ti.blacklisted = 0
+               ORDER BY ti.id DESC LIMIT 10`,
+            )
+            .all()
+        }
+        db.close()
+        signals.gillade = rows.map((r) => `${r.artist_name_guess || '?'} – ${r.title}`)
+      }
+    } catch {
+      /* kör vidare utan */
+    }
+
+    if (eff.jellyfin.apiKey && eff.jellyfin.userId) {
+      try {
+        const url =
+          `${eff.jellyfin.url}/Users/${eff.jellyfin.userId}/Items` +
+          `?IncludeItemTypes=Audio&SortBy=PlayCount&SortOrder=Descending` +
+          `&Filters=IsPlayed&Recursive=true&Limit=10`
+        const res = await fetchImpl(url, { headers: { 'X-Emby-Token': eff.jellyfin.apiKey } })
+        if (res.ok) {
+          const js = await res.json()
+          signals.mestSpelade = (js.Items ?? []).map(
+            (i) => `${(i.Artists ?? [])[0] ?? i.AlbumArtist ?? '?'} – ${i.Name}`,
+          )
+        }
+      } catch {
+        /* kör vidare utan */
+      }
+    }
+
+    return signals
+  }
+
+  function buildTrackPrompt(signals) {
+    return [
+      'Du är en kunnig musikrekommendatör. Utifrån låtarna nedan, föreslå',
+      'exakt 10 ENSKILDA LÅTAR (inte album eller artister) som användaren',
+      'troligen skulle gilla. Föreslå INTE låtar som redan finns i listorna.',
+      'Svara ENBART med en JSON-array i formatet:',
+      '[{"name":"låttitel","artist":"artistnamn","motivation":"..."}]',
+      'där "motivation" är en kort svensk mening om varför låten passar.',
+      '',
+      `Senast gillade låtar (YouTube Music): ${signals.gillade.join('; ') || '(ingen data)'}`,
+      '',
+      `Mest spelade låtar (Jellyfin): ${signals.mestSpelade.join('; ') || '(ingen data)'}`,
+    ].join('\n')
+  }
+
   function buildPrompt(signals) {
     return [
       'Du är en kunnig musikrekommendatör. Utifrån signalerna nedan, föreslå',
@@ -95,7 +165,7 @@ export function suggestEngine({ config, store, lidarr, fetchImpl = fetch }) {
     ].join('\n')
   }
 
-  async function callGemini(signals) {
+  async function callGemini(prompt) {
     const eff = effectiveConfig(config, store.load())
     if (!eff.gemini.apiKey) throw new Error('Gemini-nyckel saknas — lägg in den under ⚙ Inställningar')
     const res = await fetchImpl(
@@ -104,7 +174,7 @@ export function suggestEngine({ config, store, lidarr, fetchImpl = fetch }) {
         method: 'POST',
         headers: { 'Content-Type': 'application/json' },
         body: JSON.stringify({
-          contents: [{ parts: [{ text: buildPrompt(signals) }] }],
+          contents: [{ parts: [{ text: prompt }] }],
           generationConfig: { responseMimeType: 'application/json', temperature: 1.0 },
         }),
       },
@@ -153,26 +223,79 @@ export function suggestEngine({ config, store, lidarr, fetchImpl = fetch }) {
     return out
   }
 
+  async function enrichTracks(rawItems) {
+    const out = []
+    for (const it of rawItems.slice(0, 12)) {
+      const card = {
+        kind: 'track',
+        name: it.name,
+        secondary: it.artist ?? '',
+        motivation: it.motivation ?? '',
+        year: '',
+        mbid: null,
+        artistMbid: null,
+        albumMbid: null,
+        poster: null,
+        inLibrary: false,
+      }
+      try {
+        const hit = mapLidarrSearch(await lidarr.search(it.artist ?? it.name), 'artist')[0]
+        if (hit) {
+          card.artistMbid = hit.mbid
+          card.mbid = hit.mbid
+          card.poster = hit.poster
+        }
+      } catch {
+        /* best-effort */
+      }
+      out.push(card)
+    }
+    return out
+  }
+
+  function saveBatch(batches, batch) {
+    batches.unshift(batch)
+    saveBatches(batches)
+    return batch
+  }
+
   return {
     file,
     loadBatches,
 
-    latest(limit = 10) {
-      const items = loadBatches().flatMap((b) => b.items)
+    latest(limit = 10, type = 'mix') {
+      const items = loadBatches()
+        .filter((b) => (b.type ?? 'mix') === type)
+        .flatMap((b) => b.items)
       return items.slice(0, limit)
     },
 
-    lastRun() {
-      return loadBatches()[0]?.createdAt ?? null
+    lastRun(type = 'mix') {
+      return loadBatches().find((b) => (b.type ?? 'mix') === type)?.createdAt ?? null
     },
 
-    async run(trigger = 'manuell') {
-      const signals = await collectSignals()
-      const raw = await callGemini(signals)
-      const items = await enrich(raw)
+    async run(trigger = 'manuell', type = 'mix') {
       const batches = loadBatches()
-      const batch = {
-        id: (batches[0]?.id ?? 0) + 1,
+      const id = (batches[0]?.id ?? 0) + 1
+      if (type === 'tracks') {
+        const signals = await collectTrackSignals()
+        const raw = await callGemini(buildTrackPrompt(signals))
+        const items = await enrichTracks(raw)
+        return saveBatch(batches, {
+          id,
+          type: 'tracks',
+          createdAt: new Date().toISOString(),
+          trigger,
+          signalCounts: { gillade: signals.gillade.length, mestSpelade: signals.mestSpelade.length },
+          items,
+        })
+      }
+      const signals = await collectSignals()
+      const raw = await callGemini(buildPrompt(signals))
+      const items = await enrich(raw)
+      return saveBatch(batches, {
+        id,
+        type: 'mix',
         createdAt: new Date().toISOString(),
         trigger,
         signalCounts: {
@@ -181,10 +304,7 @@ export function suggestEngine({ config, store, lidarr, fetchImpl = fetch }) {
           tillagt: signals.nyligenTillagt.length,
         },
         items,
-      }
-      batches.unshift(batch)
-      saveBatches(batches)
-      return batch
+      })
     },
   }
 }