Förslagsmotorn: Generera-knapp, schema, diskcache och bläddringssida

- suggest.js: samlar signaler (Lidarr-bibliotek, Jellyfin senast spelat,
  Youtubarr-DB senast tillagt/gillat via better-sqlite3 ro), bygger svensk
  Gemini-prompt (JSON-svar), berikar förslagen med MBID/omslag via Lidarrs
  metadata-API, cachar batcher i /data/suggestions.json
- API: POST /api/suggest/run, GET latest (10 senaste till Upptäck),
  GET batches + batches/:id (bläddring)
- Schemaläggare i server.js: kollar var 10:e minut mot inställningen
  suggest.intervalHours (default 24, 0 = av) — ställs in under ⚙
- Upptäck: senaste 10 som kort med motivering + '✨ Generera nya förslag';
  ny Förslag-sida bläddrar alla cachade batcher; delat MusicCard-kort
  (sök + förslag) med Hämta-knapp
- Dockerfile: byggverktyg för better-sqlite3; 4 nya tester, totalt 25

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

backend/src/suggest.js

@@ -0,0 +1,190 @@
+import Database from 'better-sqlite3'
+import { existsSync, readFileSync, writeFileSync, mkdirSync } from 'node:fs'
+import path from 'node:path'
+import { effectiveConfig } from './settings.js'
+import { mapLidarrSearch } from './mapping.js'
+
+// Förslagsmotorn: samlar smak-signaler (Lidarr-bibliotek, Jellyfin-historik,
+// YT Music-tillägg via Youtubarrs databas), ber Gemini om nya förslag,
+// berikar med MBID/omslag via Lidarrs metadata-API och cachar batcher
+// på disk (/data/suggestions.json).
+export function suggestEngine({ config, store, lidarr, fetchImpl = fetch }) {
+  const file = path.join(config.dataDir ?? '/data', 'suggestions.json')
+
+  function loadBatches() {
+    try {
+      return JSON.parse(readFileSync(file, 'utf8'))
+    } catch {
+      return []
+    }
+  }
+
+  function saveBatches(batches) {
+    mkdirSync(path.dirname(file), { recursive: true })
+    writeFileSync(file, JSON.stringify(batches, null, 2))
+  }
+
+  async function collectSignals() {
+    const eff = effectiveConfig(config, store.load())
+    const signals = { bibliotek: [], nyligenSpelat: [], nyligenTillagt: [] }
+
+    try {
+      const artists = await lidarr.artists()
+      signals.bibliotek = artists.map((a) => a.artistName).slice(0, 150)
+    } catch {
+      /* biblioteket är tomt eller Lidarr nere — kör vidare */
+    }
+
+    if (eff.jellyfin.apiKey && eff.jellyfin.userId) {
+      try {
+        const url =
+          `${eff.jellyfin.url}/Users/${eff.jellyfin.userId}/Items` +
+          `?IncludeItemTypes=Audio&SortBy=DatePlayed&SortOrder=Descending` +
+          `&Filters=IsPlayed&Recursive=true&Limit=30`
+        const res = await fetchImpl(url, { headers: { 'X-Emby-Token': eff.jellyfin.apiKey } })
+        if (res.ok) {
+          const js = await res.json()
+          signals.nyligenSpelat = (js.Items ?? []).map(
+            (i) => `${(i.Artists ?? [])[0] ?? i.AlbumArtist ?? '?'} – ${i.Name}`,
+          )
+        }
+      } catch {
+        /* Jellyfin nere — kör vidare */
+      }
+    }
+
+    try {
+      if (existsSync(config.youtubarr.dbPath)) {
+        const db = new Database(config.youtubarr.dbPath, { readonly: true, fileMustExist: true })
+        const rows = db
+          .prepare(
+            `SELECT ti.title, ti.artist_name_guess, p.title AS playlist
+             FROM youtubarr_trackitem ti
+             LEFT JOIN youtubarr_playlist p ON p.id = ti.playlist_id
+             WHERE ti.blacklisted = 0
+             ORDER BY ti.id DESC LIMIT 40`,
+          )
+          .all()
+        db.close()
+        signals.nyligenTillagt = rows.map(
+          (r) => `${r.artist_name_guess || '?'} – ${r.title}${r.playlist ? ` [${r.playlist}]` : ''}`,
+        )
+      }
+    } catch {
+      /* databasen saknas/låst — kör vidare */
+    }
+
+    return signals
+  }
+
+  function buildPrompt(signals) {
+    return [
+      'Du är en kunnig musikrekommendatör. Utifrån signalerna nedan, föreslå',
+      'exakt 10 artister eller album som användaren troligen skulle gilla men',
+      'som INTE redan finns i biblioteket. Blanda gärna kända och smalare val.',
+      'Svara ENBART med en JSON-array i formatet:',
+      '[{"type":"artist"|"album","name":"...","artist":"...","motivation":"..."}]',
+      'där "artist" bara sätts för album, och "motivation" är en kort svensk',
+      'mening om varför förslaget passar.',
+      '',
+      `Bibliotek (föreslå INTE dessa): ${signals.bibliotek.join(', ') || '(tomt)'}`,
+      '',
+      `Nyligen spelat: ${signals.nyligenSpelat.join('; ') || '(ingen data)'}`,
+      '',
+      `Nyligen tillagt/gillat på YouTube Music: ${signals.nyligenTillagt.join('; ') || '(ingen data)'}`,
+    ].join('\n')
+  }
+
+  async function callGemini(signals) {
+    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(
+      `https://generativelanguage.googleapis.com/v1beta/models/${encodeURIComponent(eff.gemini.model)}:generateContent?key=${encodeURIComponent(eff.gemini.apiKey)}`,
+      {
+        method: 'POST',
+        headers: { 'Content-Type': 'application/json' },
+        body: JSON.stringify({
+          contents: [{ parts: [{ text: buildPrompt(signals) }] }],
+          generationConfig: { responseMimeType: 'application/json', temperature: 1.0 },
+        }),
+      },
+    )
+    if (!res.ok) {
+      const t = await res.text().catch(() => '')
+      throw new Error(`Gemini svarade ${res.status}: ${t.slice(0, 150)}`)
+    }
+    const js = await res.json()
+    const text = js.candidates?.[0]?.content?.parts?.[0]?.text ?? '[]'
+    const clean = text.replace(/^```(json)?\s*|\s*```$/g, '').trim()
+    const arr = JSON.parse(clean)
+    if (!Array.isArray(arr)) throw new Error('Gemini gav inte en JSON-array')
+    return arr
+  }
+
+  async function enrich(rawItems) {
+    const out = []
+    for (const it of rawItems.slice(0, 12)) {
+      const kind = it.type === 'album' ? 'album' : 'artist'
+      const card = {
+        kind,
+        name: it.name,
+        secondary: kind === 'album' ? (it.artist ?? '') : '',
+        motivation: it.motivation ?? '',
+        year: '',
+        mbid: null,
+        poster: null,
+        inLibrary: false,
+      }
+      try {
+        const term = kind === 'album' && it.artist ? `${it.artist} ${it.name}` : it.name
+        const hit = mapLidarrSearch(await lidarr.search(term), kind)[0]
+        if (hit) {
+          card.mbid = hit.mbid
+          card.poster = hit.poster
+          card.inLibrary = hit.inLibrary
+          card.year = hit.year
+          if (kind === 'album' && hit.secondary) card.secondary = hit.secondary
+        }
+      } catch {
+        /* berikning är best-effort */
+      }
+      out.push(card)
+    }
+    return out
+  }
+
+  return {
+    file,
+    loadBatches,
+
+    latest(limit = 10) {
+      const items = loadBatches().flatMap((b) => b.items)
+      return items.slice(0, limit)
+    },
+
+    lastRun() {
+      return loadBatches()[0]?.createdAt ?? null
+    },
+
+    async run(trigger = 'manuell') {
+      const signals = await collectSignals()
+      const raw = await callGemini(signals)
+      const items = await enrich(raw)
+      const batches = loadBatches()
+      const batch = {
+        id: (batches[0]?.id ?? 0) + 1,
+        createdAt: new Date().toISOString(),
+        trigger,
+        signalCounts: {
+          bibliotek: signals.bibliotek.length,
+          spelat: signals.nyligenSpelat.length,
+          tillagt: signals.nyligenTillagt.length,
+        },
+        items,
+      }
+      batches.unshift(batch)
+      saveBatches(batches)
+      return batch
+    },
+  }
+}